Google Git
Sign in
gerrit/gerrit/deaba768b1042e08c0c0a732f3202ffe106ea038/./polygerrit-ui/app/elements/diff/gr-diff-view/gr-diff-view_test.html
blob: b33c54cf22fdd07bc637817153ce7ed5517e23b3 [file] [log] [blame]
Andrew Bonventreab0f6a82015-11-14 15:40:47 -0500[diff] [blame]1<!DOCTYPE html>
2<!--
Dave Borowitz8cdc76b2018-03-26 10:04:27 -0400[diff] [blame]3@license
Andrew Bonventreab0f6a82015-11-14 15:40:47 -0500[diff] [blame]4Copyright (C) 2015 The Android Open Source Project
5
6Licensed under the Apache License, Version 2.0 (the "License");
7you may not use this file except in compliance with the License.
8You may obtain a copy of the License at
9
10http://www.apache.org/licenses/LICENSE-2.0
11
12Unless required by applicable law or agreed to in writing, software
13distributed under the License is distributed on an "AS IS" BASIS,
14WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15See the License for the specific language governing permissions and
16limitations under the License.
17-->
18
19<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">
Andrew Bonventre4c944782015-11-18 16:31:18 -0500[diff] [blame]20<title>gr-diff-view</title>
Andrew Bonventreab0f6a82015-11-14 15:40:47 -0500[diff] [blame]21
Viktar Donich29e1ce52017-03-28 17:02:44 -0700[diff] [blame]22<script src="../../../bower_components/webcomponentsjs/webcomponents-lite.min.js"></script>
Andrew Bonventre78792e82016-03-04 17:48:22 -0500[diff] [blame]23<script src="../../../bower_components/web-component-tester/browser.js"></script>
Mike Samuele07c4b22017-06-02 13:08:19 -0400[diff] [blame]24<link rel="import" href="../../../test/common-test-setup.html"/>
Andrew Bonventre78792e82016-03-04 17:48:22 -0500[diff] [blame]25<script src="../../../bower_components/page/page.js"></script>
Andrew Bonventre78792e82016-03-04 17:48:22 -0500[diff] [blame]26<script src="../../../scripts/util.js"></script>
Andrew Bonventre18f76a62015-11-25 19:08:45 -0500[diff] [blame]27
Andrew Bonventre78792e82016-03-04 17:48:22 -0500[diff] [blame]28<link rel="import" href="gr-diff-view.html">
Andrew Bonventreab0f6a82015-11-14 15:40:47 -0500[diff] [blame]29
Viktar Donich29e1ce52017-03-28 17:02:44 -0700[diff] [blame]30<script>void(0);</script>
31
Andrew Bonventreab0f6a82015-11-14 15:40:47 -0500[diff] [blame]32<test-fixture id="basic">
33 <template>
Andrew Bonventre0601fc72015-12-02 13:17:35 -0500[diff] [blame]34 <gr-diff-view></gr-diff-view>
35 </template>
36</test-fixture>
37
Logan Hanks78ad03c2016-08-25 12:35:50 -0700[diff] [blame]38<test-fixture id="blank">
39 <template>
40 <div></div>
41 </template>
beckysiegelc47410c2016-09-16 10:44:37 -0700[diff] [blame]42</test-fixture>
Logan Hanks78ad03c2016-08-25 12:35:50 -0700[diff] [blame]43
Andrew Bonventreab0f6a82015-11-14 15:40:47 -0500[diff] [blame]44<script>
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]45 suite('gr-diff-view tests', () => {
Logan Hanks5cde0842018-10-05 15:56:10 -0700[diff] [blame]46 const kb = window.Gerrit.KeyboardShortcutBinder;
47 kb.bindShortcut(kb.Shortcut.LEFT_PANE, 'shift+left');
48 kb.bindShortcut(kb.Shortcut.RIGHT_PANE, 'shift+right');
49 kb.bindShortcut(kb.Shortcut.NEXT_LINE, 'j', 'down');
50 kb.bindShortcut(kb.Shortcut.PREV_LINE, 'k', 'up');
51 kb.bindShortcut(kb.Shortcut.NEXT_FILE_WITH_COMMENTS, 'shift+j');
52 kb.bindShortcut(kb.Shortcut.PREV_FILE_WITH_COMMENTS, 'shift+k');
53 kb.bindShortcut(kb.Shortcut.NEW_COMMENT, 'c');
54 kb.bindShortcut(kb.Shortcut.SAVE_COMMENT, 'ctrl+s');
55 kb.bindShortcut(kb.Shortcut.NEXT_FILE, ']');
56 kb.bindShortcut(kb.Shortcut.PREV_FILE, '[');
57 kb.bindShortcut(kb.Shortcut.NEXT_CHUNK, 'n');
58 kb.bindShortcut(kb.Shortcut.NEXT_COMMENT_THREAD, 'shift+n');
59 kb.bindShortcut(kb.Shortcut.PREV_CHUNK, 'p');
60 kb.bindShortcut(kb.Shortcut.PREV_COMMENT_THREAD, 'shift+p');
61 kb.bindShortcut(kb.Shortcut.OPEN_REPLY_DIALOG, 'a');
62 kb.bindShortcut(kb.Shortcut.TOGGLE_LEFT_PANE, 'shift+a');
63 kb.bindShortcut(kb.Shortcut.UP_TO_CHANGE, 'u');
64 kb.bindShortcut(kb.Shortcut.OPEN_DIFF_PREFS, ',');
65 kb.bindShortcut(kb.Shortcut.TOGGLE_DIFF_MODE, 'm');
66 kb.bindShortcut(kb.Shortcut.TOGGLE_FILE_REVIEWED, 'r');
67 kb.bindShortcut(kb.Shortcut.EXPAND_ALL_DIFF_CONTEXT, 'shift+x');
68 kb.bindShortcut(kb.Shortcut.EXPAND_ALL_COMMENT_THREADS, 'e');
69 kb.bindShortcut(kb.Shortcut.COLLAPSE_ALL_COMMENT_THREADS, 'shift+e');
Kasper Nilsson30d54102018-11-12 10:55:29 -0800[diff] [blame]70 kb.bindShortcut(kb.Shortcut.NEXT_UNREVIEWED_FILE, 'shift+m');
Logan Hanks5cde0842018-10-05 15:56:10 -0700[diff] [blame]71
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]72 let element;
73 let sandbox;
Andrew Bonventre0601fc72015-12-02 13:17:35 -0500[diff] [blame]74
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]75 const PARENT = 'PARENT';
76
Kasper Nilssonb1e23072018-01-23 10:33:44 -0800[diff] [blame]77 setup(() => {
Wyatt Allen43ddaf62016-10-26 17:11:50 -0700[diff] [blame]78 sandbox = sinon.sandbox.create();
79
Andrew Bonventrecfacb802016-03-29 14:06:39 -0400[diff] [blame]80 stub('gr-rest-api-interface', {
Dmitrii Filippov3d73c6a2020-05-06 14:06:27 +0200[diff] [blame]81 getConfig() {
82 return Promise.resolve({change: {}});
83 },
84 getLoggedIn() {
85 return Promise.resolve(false);
86 },
87 getProjectConfig() {
88 return Promise.resolve({});
89 },
90 getDiffChangeDetail() {
91 return Promise.resolve({});
92 },
93 getChangeFiles() {
94 return Promise.resolve({});
95 },
96 saveFileReviewed() {
97 return Promise.resolve();
98 },
99 getDiffComments() {
100 return Promise.resolve({});
101 },
102 getDiffRobotComments() {
103 return Promise.resolve({});
104 },
105 getDiffDrafts() {
106 return Promise.resolve({});
107 },
108 getReviewedFiles() {
109 return Promise.resolve([]);
110 },
Andrew Bonventrecfacb802016-03-29 14:06:39 -0400[diff] [blame]111 });
Andrew Bonventreab0f6a82015-11-14 15:40:47 -0500[diff] [blame]112 element = fixture('basic');
Kasper Nilssonb1e23072018-01-23 10:33:44 -0800[diff] [blame]113 return element._loadComments();
Andrew Bonventre0601fc72015-12-02 13:17:35 -0500[diff] [blame]114 });
Andrew Bonventreab0f6a82015-11-14 15:40:47 -0500[diff] [blame]115
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]116 teardown(() => {
Wyatt Allen43ddaf62016-10-26 17:11:50 -0700[diff] [blame]117 sandbox.restore();
118 });
119
Viktar Donich36e8ba42018-04-20 13:03:19 -0700[diff] [blame]120 test('params change triggers diffViewDisplayed()', () => {
121 sandbox.stub(element.$.reporting, 'diffViewDisplayed');
Ole Rehmsene5de55e2018-08-23 16:52:57 +0200[diff] [blame]122 sandbox.stub(element.$.diffHost, 'reload').returns(Promise.resolve());
Viktar Donich36e8ba42018-04-20 13:03:19 -0700[diff] [blame]123 sandbox.spy(element, '_paramsChanged');
124 element.params = {
125 view: Gerrit.Nav.View.DIFF,
126 changeNum: '42',
127 patchNum: '2',
128 basePatchNum: '1',
129 path: '/COMMIT_MSG',
130 };
131
132 return element._paramsChanged.returnValues[0].then(() => {
133 assert.isTrue(element.$.reporting.diffViewDisplayed.calledOnce);
134 });
135 });
136
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]137 test('toggle left diff with a hotkey', () => {
Ole Rehmsene5de55e2018-08-23 16:52:57 +0200[diff] [blame]138 const toggleLeftDiffStub = sandbox.stub(
139 element.$.diffHost, 'toggleLeftDiff');
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]140 MockInteractions.pressAndReleaseKeyOn(element, 65, 'shift', 'a');
Viktar Donichc282d7b2016-08-10 11:53:12 -0700[diff] [blame]141 assert.isTrue(toggleLeftDiffStub.calledOnce);
Viktar Donichc282d7b2016-08-10 11:53:12 -0700[diff] [blame]142 });
143
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]144 test('keyboard shortcuts', () => {
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]145 element._changeNum = '42';
Andrew Bonventre1aa7b902015-12-11 12:02:57 -0500[diff] [blame]146 element._patchRange = {
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]147 basePatchNum: PARENT,
Andrew Bonventre1aa7b902015-12-11 12:02:57 -0500[diff] [blame]148 patchNum: '10',
149 };
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]150 element._change = {
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]151 _number: 42,
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]152 revisions: {
Wyatt Allena744e232017-11-08 15:33:48 -0800[diff] [blame]153 a: {_number: 10, commit: {parents: []}},
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]154 },
155 };
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]156 element._fileList = ['chell.go', 'glados.txt', 'wheatley.md'];
157 element._path = 'glados.txt';
Andrew Bonventre4a8fff22016-02-03 20:40:36 -0800[diff] [blame]158 element.changeViewState.selectedFileIndex = 1;
Kasper Nilsson52053a42018-11-08 09:28:01 -0800[diff] [blame]159 element._loggedIn = true;
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]160
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]161 const diffNavStub = sandbox.stub(Gerrit.Nav, 'navigateToDiff');
162 const changeNavStub = sandbox.stub(Gerrit.Nav, 'navigateToChange');
163
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]164 MockInteractions.pressAndReleaseKeyOn(element, 85, null, 'u');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]165 assert(changeNavStub.lastCall.calledWith(element._change),
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]166 'Should navigate to /c/42/');
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]167
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]168 MockInteractions.pressAndReleaseKeyOn(element, 221, null, ']');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]169 assert(diffNavStub.lastCall.calledWith(element._change, 'wheatley.md',
170 '10', PARENT), 'Should navigate to /c/42/10/wheatley.md');
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]171 element._path = 'wheatley.md';
Andrew Bonventre4a8fff22016-02-03 20:40:36 -0800[diff] [blame]172 assert.equal(element.changeViewState.selectedFileIndex, 2);
Kasper Nilsson29b2ab42017-10-09 11:36:19 -0700[diff] [blame]173 assert.isTrue(element._loading);
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]174
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]175 MockInteractions.pressAndReleaseKeyOn(element, 219, null, '[');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]176 assert(diffNavStub.lastCall.calledWith(element._change, 'glados.txt',
177 '10', PARENT), 'Should navigate to /c/42/10/glados.txt');
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]178 element._path = 'glados.txt';
Andrew Bonventre4a8fff22016-02-03 20:40:36 -0800[diff] [blame]179 assert.equal(element.changeViewState.selectedFileIndex, 1);
Kasper Nilsson29b2ab42017-10-09 11:36:19 -0700[diff] [blame]180 assert.isTrue(element._loading);
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]181
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]182 MockInteractions.pressAndReleaseKeyOn(element, 219, null, '[');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]183 assert(diffNavStub.lastCall.calledWith(element._change, 'chell.go', '10',
184 PARENT), 'Should navigate to /c/42/10/chell.go');
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]185 element._path = 'chell.go';
Andrew Bonventre4a8fff22016-02-03 20:40:36 -0800[diff] [blame]186 assert.equal(element.changeViewState.selectedFileIndex, 0);
Kasper Nilsson29b2ab42017-10-09 11:36:19 -0700[diff] [blame]187 assert.isTrue(element._loading);
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]188
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]189 MockInteractions.pressAndReleaseKeyOn(element, 219, null, '[');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]190 assert(changeNavStub.lastCall.calledWith(element._change),
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]191 'Should navigate to /c/42/');
Andrew Bonventre4a8fff22016-02-03 20:40:36 -0800[diff] [blame]192 assert.equal(element.changeViewState.selectedFileIndex, 0);
Kasper Nilsson29b2ab42017-10-09 11:36:19 -0700[diff] [blame]193 assert.isTrue(element._loading);
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]194
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]195 const showPrefsStub =
Paladox none7a2280c2019-02-19 22:07:54 +0000[diff] [blame]196 sandbox.stub(element.$.diffPreferencesDialog, 'open',
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]197 () => Promise.resolve());
beckysiegelc47410c2016-09-16 10:44:37 -0700[diff] [blame]198
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]199 MockInteractions.pressAndReleaseKeyOn(element, 188, null, ',');
Andrew Bonventre33543b72016-01-26 16:30:02 -0500[diff] [blame]200 assert(showPrefsStub.calledOnce);
201
Kasper Nilsson52053a42018-11-08 09:28:01 -0800[diff] [blame]202 element.disableDiffPrefs = true;
203 MockInteractions.pressAndReleaseKeyOn(element, 188, null, ',');
204 assert(showPrefsStub.calledOnce);
205
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]206 let scrollStub = sandbox.stub(element.$.cursor, 'moveToNextChunk');
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]207 MockInteractions.pressAndReleaseKeyOn(element, 78, null, 'n');
Andrew Bonventre15f796c2016-02-25 18:19:51 -0500[diff] [blame]208 assert(scrollStub.calledOnce);
Andrew Bonventre15f796c2016-02-25 18:19:51 -0500[diff] [blame]209
Wyatt Allen43ddaf62016-10-26 17:11:50 -0700[diff] [blame]210 scrollStub = sandbox.stub(element.$.cursor, 'moveToPreviousChunk');
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]211 MockInteractions.pressAndReleaseKeyOn(element, 80, null, 'p');
Andrew Bonventre15f796c2016-02-25 18:19:51 -0500[diff] [blame]212 assert(scrollStub.calledOnce);
Andrew Bonventre15f796c2016-02-25 18:19:51 -0500[diff] [blame]213
Wyatt Allen43ddaf62016-10-26 17:11:50 -0700[diff] [blame]214 scrollStub = sandbox.stub(element.$.cursor, 'moveToNextCommentThread');
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]215 MockInteractions.pressAndReleaseKeyOn(element, 78, 'shift', 'n');
Andrew Bonventre15f796c2016-02-25 18:19:51 -0500[diff] [blame]216 assert(scrollStub.calledOnce);
Andrew Bonventre15f796c2016-02-25 18:19:51 -0500[diff] [blame]217
Wyatt Allen43ddaf62016-10-26 17:11:50 -0700[diff] [blame]218 scrollStub = sandbox.stub(element.$.cursor,
219 'moveToPreviousCommentThread');
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]220 MockInteractions.pressAndReleaseKeyOn(element, 80, 'shift', 'p');
Andrew Bonventre15f796c2016-02-25 18:19:51 -0500[diff] [blame]221 assert(scrollStub.calledOnce);
Becky Siegel6a7085e2016-11-02 16:25:53 -0700[diff] [blame]222
Ole Rehmsene5de55e2018-08-23 16:52:57 +0200[diff] [blame]223 const computeContainerClassStub = sandbox.stub(element.$.diffHost.$.diff,
Becky Siegel6a7085e2016-11-02 16:25:53 -0700[diff] [blame]224 '_computeContainerClass');
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]225 MockInteractions.pressAndReleaseKeyOn(element, 74, null, 'j');
Becky Siegel6a7085e2016-11-02 16:25:53 -0700[diff] [blame]226 assert(computeContainerClassStub.lastCall.calledWithExactly(
227 false, 'SIDE_BY_SIDE', true));
228
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]229 MockInteractions.pressAndReleaseKeyOn(element, 27, null, 'esc');
Becky Siegel6a7085e2016-11-02 16:25:53 -0700[diff] [blame]230 assert(computeContainerClassStub.lastCall.calledWithExactly(
231 false, 'SIDE_BY_SIDE', false));
Kasper Nilsson5b7e0af2018-02-20 13:13:27 -0800[diff] [blame]232
233 sandbox.stub(element, '_setReviewed');
234 element.$.reviewed.checked = false;
235 MockInteractions.pressAndReleaseKeyOn(element, 82, 'shift', 'r');
236 assert.isFalse(element._setReviewed.called);
237
238 MockInteractions.pressAndReleaseKeyOn(element, 82, null, 'r');
239 assert.isTrue(element._setReviewed.called);
240 assert.equal(element._setReviewed.lastCall.args[0], true);
Andrew Bonventre0a250522016-01-08 10:13:54 -0500[diff] [blame]241 });
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]242
Kasper Nilsson5ed90422018-06-15 10:05:21 -0700[diff] [blame]243 test('shift+x shortcut expands all diff context', () => {
Ole Rehmsene5de55e2018-08-23 16:52:57 +0200[diff] [blame]244 const expandStub = sandbox.stub(element.$.diffHost, 'expandAllContext');
Kasper Nilsson5ed90422018-06-15 10:05:21 -0700[diff] [blame]245 MockInteractions.pressAndReleaseKeyOn(element, 88, 'shift', 'x');
246 flushAsynchronousOperations();
247 assert.isTrue(expandStub.called);
248 });
249
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]250 test('keyboard shortcuts with patch range', () => {
Andrew Bonventre0a250522016-01-08 10:13:54 -0500[diff] [blame]251 element._changeNum = '42';
252 element._patchRange = {
253 basePatchNum: '5',
254 patchNum: '10',
255 };
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]256 element._change = {
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]257 _number: 42,
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]258 revisions: {
Wyatt Allena744e232017-11-08 15:33:48 -0800[diff] [blame]259 a: {_number: 10, commit: {parents: []}},
260 b: {_number: 5, commit: {parents: []}},
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]261 },
262 };
Andrew Bonventre0a250522016-01-08 10:13:54 -0500[diff] [blame]263 element._fileList = ['chell.go', 'glados.txt', 'wheatley.md'];
264 element._path = 'glados.txt';
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]265
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]266 const diffNavStub = sandbox.stub(Gerrit.Nav, 'navigateToDiff');
267 const changeNavStub = sandbox.stub(Gerrit.Nav, 'navigateToChange');
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]268
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]269 MockInteractions.pressAndReleaseKeyOn(element, 65, null, 'a');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]270 assert.isTrue(changeNavStub.notCalled, 'The `a` keyboard shortcut ' +
271 'should only work when the user is logged in.');
Andrew Bonventre349380e2016-01-28 14:58:04 -0500[diff] [blame]272 assert.isNull(window.sessionStorage.getItem(
Andrew Bonventre882043f2016-02-22 18:12:27 -0500[diff] [blame]273 'changeView.showReplyDialog'));
Andrew Bonventre349380e2016-01-28 14:58:04 -0500[diff] [blame]274
275 element._loggedIn = true;
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]276 MockInteractions.pressAndReleaseKeyOn(element, 65, null, 'a');
Andrew Bonventre882043f2016-02-22 18:12:27 -0500[diff] [blame]277 assert.isTrue(element.changeViewState.showReplyDialog);
Andrew Bonventre4a8fff22016-02-03 20:40:36 -0800[diff] [blame]278
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]279 assert(changeNavStub.lastCall.calledWithExactly(element._change, '10',
280 '5'), 'Should navigate to /c/42/5..10');
Andrew Bonventre349380e2016-01-28 14:58:04 -0500[diff] [blame]281
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]282 MockInteractions.pressAndReleaseKeyOn(element, 85, null, 'u');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]283 assert(changeNavStub.lastCall.calledWithExactly(element._change, '10',
284 '5'), 'Should navigate to /c/42/5..10');
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]285
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]286 MockInteractions.pressAndReleaseKeyOn(element, 221, null, ']');
Kasper Nilsson29b2ab42017-10-09 11:36:19 -0700[diff] [blame]287 assert.isTrue(element._loading);
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]288 assert(diffNavStub.lastCall.calledWithExactly(element._change,
289 'wheatley.md', '10', '5'),
Thomas Draebing6ff72df2019-12-27 10:58:03 +0100[diff] [blame]290 'Should navigate to /c/42/5..10/wheatley.md');
Andrew Bonventre0a250522016-01-08 10:13:54 -0500[diff] [blame]291 element._path = 'wheatley.md';
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]292
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]293 MockInteractions.pressAndReleaseKeyOn(element, 219, null, '[');
Kasper Nilsson29b2ab42017-10-09 11:36:19 -0700[diff] [blame]294 assert.isTrue(element._loading);
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]295 assert(diffNavStub.lastCall.calledWithExactly(element._change,
296 'glados.txt', '10', '5'),
Thomas Draebing6ff72df2019-12-27 10:58:03 +0100[diff] [blame]297 'Should navigate to /c/42/5..10/glados.txt');
Andrew Bonventre0a250522016-01-08 10:13:54 -0500[diff] [blame]298 element._path = 'glados.txt';
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]299
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]300 MockInteractions.pressAndReleaseKeyOn(element, 219, null, '[');
Kasper Nilsson29b2ab42017-10-09 11:36:19 -0700[diff] [blame]301 assert.isTrue(element._loading);
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]302 assert(diffNavStub.lastCall.calledWithExactly(element._change, 'chell.go',
303 '10', '5'),
Thomas Draebing6ff72df2019-12-27 10:58:03 +0100[diff] [blame]304 'Should navigate to /c/42/5..10/chell.go');
Andrew Bonventre0a250522016-01-08 10:13:54 -0500[diff] [blame]305 element._path = 'chell.go';
Andrew Bonventre547b8ab2015-12-01 01:02:00 -0500[diff] [blame]306
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]307 MockInteractions.pressAndReleaseKeyOn(element, 219, null, '[');
Kasper Nilsson29b2ab42017-10-09 11:36:19 -0700[diff] [blame]308 assert.isTrue(element._loading);
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]309 assert(changeNavStub.lastCall.calledWithExactly(element._change, '10',
310 '5'),
Thomas Draebing6ff72df2019-12-27 10:58:03 +0100[diff] [blame]311 'Should navigate to /c/42/5..10');
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]312 });
313
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]314 test('keyboard shortcuts with old patch number', () => {
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]315 element._changeNum = '42';
316 element._patchRange = {
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]317 basePatchNum: PARENT,
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]318 patchNum: '1',
319 };
320 element._change = {
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]321 _number: 42,
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]322 revisions: {
Wyatt Allena744e232017-11-08 15:33:48 -0800[diff] [blame]323 a: {_number: 1, commit: {parents: []}},
324 b: {_number: 2, commit: {parents: []}},
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]325 },
326 };
327 element._fileList = ['chell.go', 'glados.txt', 'wheatley.md'];
328 element._path = 'glados.txt';
329
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]330 const diffNavStub = sandbox.stub(Gerrit.Nav, 'navigateToDiff');
331 const changeNavStub = sandbox.stub(Gerrit.Nav, 'navigateToChange');
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]332
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]333 MockInteractions.pressAndReleaseKeyOn(element, 65, null, 'a');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]334 assert.isTrue(changeNavStub.notCalled, 'The `a` keyboard shortcut ' +
335 'should only work when the user is logged in.');
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]336 assert.isNull(window.sessionStorage.getItem(
337 'changeView.showReplyDialog'));
338
339 element._loggedIn = true;
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]340 MockInteractions.pressAndReleaseKeyOn(element, 65, null, 'a');
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]341 assert.isTrue(element.changeViewState.showReplyDialog);
342
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]343 assert(changeNavStub.lastCall.calledWithExactly(element._change, '1',
344 PARENT), 'Should navigate to /c/42/1');
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]345
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]346 MockInteractions.pressAndReleaseKeyOn(element, 85, null, 'u');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]347 assert(changeNavStub.lastCall.calledWithExactly(element._change, '1',
348 PARENT), 'Should navigate to /c/42/1');
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]349
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]350 MockInteractions.pressAndReleaseKeyOn(element, 221, null, ']');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]351 assert(diffNavStub.lastCall.calledWithExactly(element._change,
352 'wheatley.md', '1', PARENT),
Thomas Draebing6ff72df2019-12-27 10:58:03 +0100[diff] [blame]353 'Should navigate to /c/42/1/wheatley.md');
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]354 element._path = 'wheatley.md';
355
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]356 MockInteractions.pressAndReleaseKeyOn(element, 219, null, '[');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]357 assert(diffNavStub.lastCall.calledWithExactly(element._change,
358 'glados.txt', '1', PARENT),
Thomas Draebing6ff72df2019-12-27 10:58:03 +0100[diff] [blame]359 'Should navigate to /c/42/1/glados.txt');
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]360 element._path = 'glados.txt';
361
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]362 MockInteractions.pressAndReleaseKeyOn(element, 219, null, '[');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]363 assert(diffNavStub.lastCall.calledWithExactly(element._change, 'chell.go',
364 '1', PARENT), 'Should navigate to /c/42/1/chell.go');
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]365 element._path = 'chell.go';
366
Andrew Bonventre4d22c7e2016-11-15 17:01:15 -0800[diff] [blame]367 MockInteractions.pressAndReleaseKeyOn(element, 219, null, '[');
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]368 assert(changeNavStub.lastCall.calledWithExactly(element._change, '1',
369 PARENT), 'Should navigate to /c/42/1');
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]370 });
371
Tao Zhou24c6b9a2020-02-27 15:59:39 +0100[diff] [blame]372 test('edit should redirect to edit page', done => {
373 element._loggedIn = true;
374 element._path = 't.txt';
375 element._patchRange = {
376 basePatchNum: PARENT,
377 patchNum: '1',
378 };
379 element._change = {
380 _number: 42,
Dmitrii Filippov3d73c6a2020-05-06 14:06:27 +0200[diff] [blame]381 status: 'NEW',
Tao Zhou24c6b9a2020-02-27 15:59:39 +0100[diff] [blame]382 revisions: {
383 a: {_number: 1, commit: {parents: []}},
384 b: {_number: 2, commit: {parents: []}},
385 },
386 };
387 const redirectStub = sandbox.stub(Gerrit.Nav, 'navigateToRelativeUrl');
388 flush(() => {
389 const editBtn = Polymer.dom(element.root)
390 .querySelector('.editButton gr-button');
391 assert.isTrue(!!editBtn);
392 MockInteractions.tap(editBtn);
393 assert.isTrue(redirectStub.called);
Tao Zhou24c6b9a2020-02-27 15:59:39 +0100[diff] [blame]394 done();
395 });
396 });
397
Dmitrii Filippov3d73c6a2020-05-06 14:06:27 +0200[diff] [blame]398 function isEditVisibile({loggedIn, changeStatus}) {
399 return new Promise(resolve => {
400 element._loggedIn = loggedIn;
401 element._path = 't.txt';
402 element._patchRange = {
403 basePatchNum: PARENT,
404 patchNum: '1',
405 };
406 element._change = {
407 _number: 42,
408 status: changeStatus,
409 revisions: {
410 a: {_number: 1, commit: {parents: []}},
411 b: {_number: 2, commit: {parents: []}},
412 },
413 };
414 flush(() => {
415 const editBtn = Polymer.dom(element.root)
416 .querySelector('.editButton gr-button');
417 resolve(!!editBtn);
418 });
Tao Zhou24c6b9a2020-02-27 15:59:39 +0100[diff] [blame]419 });
Dmitrii Filippov3d73c6a2020-05-06 14:06:27 +0200[diff] [blame]420 }
421
422 test('edit visible only when logged and status NEW', async () => {
423 for (const changeStatus in element.ChangeStatus) {
424 if (!element.ChangeStatus.hasOwnProperty(changeStatus)) {
425 continue;
426 }
427 assert.isFalse(await isEditVisibile({loggedIn: false, changeStatus}),
428 `loggedIn: false, changeStatus: ${changeStatus}`);
429
430 if (changeStatus !== element.ChangeStatus.NEW) {
431 assert.isFalse(await isEditVisibile({loggedIn: true, changeStatus}),
432 `loggedIn: true, changeStatus: ${changeStatus}`);
433 } else {
434 assert.isTrue(await isEditVisibile({loggedIn: true, changeStatus}),
435 `loggedIn: true, changeStatus: ${changeStatus}`);
436 }
437 }
438 });
439
440 test('edit visible when logged and status NEW', async () => {
441 assert.isTrue(await isEditVisibile(
442 {loggedIn: true, changeStatus: element.ChangeStatus.NEW}));
443 });
444
445 test('edit hidden when logged and status ABANDONED', async () => {
446 assert.isFalse(await isEditVisibile(
447 {loggedIn: true, changeStatus: element.ChangeStatus.ABANDONED}));
448 });
449
450 test('edit hidden when logged and status MERGED', async () => {
451 assert.isFalse(await isEditVisibile(
452 {loggedIn: true, changeStatus: element.ChangeStatus.MERGED}));
Paladox nonece1be9f2020-02-05 14:52:03 +0000[diff] [blame]453 });
454
Kasper Nilsson52053a42018-11-08 09:28:01 -0800[diff] [blame]455 suite('diff prefs hidden', () => {
456 test('when no prefs or logged out', () => {
457 element.disableDiffPrefs = false;
458 element._loggedIn = false;
459 flushAsynchronousOperations();
460 assert.isTrue(element.$.diffPrefsContainer.hidden);
Becky Siegel70a82692017-05-08 14:41:57 -0700[diff] [blame]461
Kasper Nilsson52053a42018-11-08 09:28:01 -0800[diff] [blame]462 element._loggedIn = true;
463 flushAsynchronousOperations();
464 assert.isTrue(element.$.diffPrefsContainer.hidden);
Becky Siegel70a82692017-05-08 14:41:57 -0700[diff] [blame]465
Kasper Nilsson52053a42018-11-08 09:28:01 -0800[diff] [blame]466 element._loggedIn = false;
467 element._prefs = {font_size: '12'};
468 flushAsynchronousOperations();
469 assert.isTrue(element.$.diffPrefsContainer.hidden);
Becky Siegel70a82692017-05-08 14:41:57 -0700[diff] [blame]470
Kasper Nilsson52053a42018-11-08 09:28:01 -0800[diff] [blame]471 element._loggedIn = true;
472 flushAsynchronousOperations();
473 assert.isFalse(element.$.diffPrefsContainer.hidden);
474 });
475
476 test('when disableDiffPrefs is set', () => {
477 element._loggedIn = true;
478 element._prefs = {font_size: '12'};
479 element.disableDiffPrefs = false;
480 flushAsynchronousOperations();
481
482 assert.isFalse(element.$.diffPrefsContainer.hidden);
483 element.disableDiffPrefs = true;
484 flushAsynchronousOperations();
485
486 assert.isTrue(element.$.diffPrefsContainer.hidden);
487 });
Becky Siegel70a82692017-05-08 14:41:57 -0700[diff] [blame]488 });
489
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]490 test('prefsButton opens gr-diff-preferences', () => {
491 const handlePrefsTapSpy = sandbox.spy(element, '_handlePrefsTap');
Paladox none7a2280c2019-02-19 22:07:54 +0000[diff] [blame]492 const overlayOpenStub = sandbox.stub(element.$.diffPreferencesDialog,
Becky Siegel70a82692017-05-08 14:41:57 -0700[diff] [blame]493 'open');
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]494 const prefsButton =
495 Polymer.dom(element.root).querySelector('.prefsButton');
Becky Siegel70a82692017-05-08 14:41:57 -0700[diff] [blame]496
497 MockInteractions.tap(prefsButton);
498
499 assert.isTrue(handlePrefsTapSpy.called);
500 assert.isTrue(overlayOpenStub.called);
501 });
502
Becky Siegel5946f952017-11-09 11:53:33 -0800[diff] [blame]503 test('_computeCommentString', done => {
504 loadCommentSpy = sandbox.spy(element.$.commentAPI, 'loadAll');
505 const path = '/test';
506 element.$.commentAPI.loadAll().then(comments => {
507 const commentCountStub =
508 sandbox.stub(comments, 'computeCommentCount');
509 const unresolvedCountStub =
510 sandbox.stub(comments, 'computeUnresolvedNum');
511 commentCountStub.withArgs(1, path).returns(0);
512 commentCountStub.withArgs(2, path).returns(1);
513 commentCountStub.withArgs(3, path).returns(2);
514 commentCountStub.withArgs(4, path).returns(0);
515 unresolvedCountStub.withArgs(1, path).returns(1);
516 unresolvedCountStub.withArgs(2, path).returns(0);
517 unresolvedCountStub.withArgs(3, path).returns(2);
518 unresolvedCountStub.withArgs(4, path).returns(0);
519
520 assert.equal(element._computeCommentString(comments, 1, path),
521 '1 unresolved');
522 assert.equal(element._computeCommentString(comments, 2, path),
523 '1 comment');
524 assert.equal(element._computeCommentString(comments, 3, path),
525 '2 comments, 2 unresolved');
526 assert.equal(element._computeCommentString(comments, 4, path), '');
527 done();
528 });
529 });
530
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]531 suite('url params', () => {
532 setup(() => {
533 sandbox.stub(Gerrit.Nav, 'getUrlForDiff', (c, p, pn, bpn) => {
534 return `${c._number}-${p}-${pn}-${bpn}`;
535 });
536 sandbox.stub(Gerrit.Nav, 'getUrlForChange', (c, pn, bpn) => {
537 return `${c._number}-${pn}-${bpn}`;
538 });
539 });
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]540
Becky Siegelfde2da62017-11-07 15:49:55 -0800[diff] [blame]541 test('_formattedFiles', () => {
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]542 element._changeNum = '42';
543 element._patchRange = {
544 basePatchNum: PARENT,
545 patchNum: '10',
546 };
547 element._change = {_number: 42};
Becky Siegele53ca1c2017-11-13 16:23:08 -0800[diff] [blame]548 element._fileList = ['chell.go', 'glados.txt', 'wheatley.md',
549 '/COMMIT_MSG', '/MERGE_LIST'];
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]550 element._path = 'glados.txt';
Becky Siegelfde2da62017-11-07 15:49:55 -0800[diff] [blame]551 const expectedFormattedFiles = [
552 {
553 text: 'chell.go',
554 mobileText: 'chell.go',
555 value: 'chell.go',
Becky Siegel5946f952017-11-09 11:53:33 -0800[diff] [blame]556 bottomText: '',
Becky Siegelfde2da62017-11-07 15:49:55 -0800[diff] [blame]557 }, {
558 text: 'glados.txt',
559 mobileText: 'glados.txt',
560 value: 'glados.txt',
Becky Siegel5946f952017-11-09 11:53:33 -0800[diff] [blame]561 bottomText: '',
Becky Siegelfde2da62017-11-07 15:49:55 -0800[diff] [blame]562 }, {
563 text: 'wheatley.md',
564 mobileText: 'wheatley.md',
565 value: 'wheatley.md',
Becky Siegel5946f952017-11-09 11:53:33 -0800[diff] [blame]566 bottomText: '',
Becky Siegelfde2da62017-11-07 15:49:55 -0800[diff] [blame]567 },
Becky Siegele53ca1c2017-11-13 16:23:08 -0800[diff] [blame]568 {
569 text: 'Commit message',
570 mobileText: 'Commit message',
571 value: '/COMMIT_MSG',
Becky Siegel5946f952017-11-09 11:53:33 -0800[diff] [blame]572 bottomText: '',
Becky Siegele53ca1c2017-11-13 16:23:08 -0800[diff] [blame]573 },
574 {
575 text: 'Merge list',
576 mobileText: 'Merge list',
577 value: '/MERGE_LIST',
Becky Siegel5946f952017-11-09 11:53:33 -0800[diff] [blame]578 bottomText: '',
Becky Siegele53ca1c2017-11-13 16:23:08 -0800[diff] [blame]579 },
Becky Siegelfde2da62017-11-07 15:49:55 -0800[diff] [blame]580 ];
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]581
Becky Siegelfde2da62017-11-07 15:49:55 -0800[diff] [blame]582 assert.deepEqual(element._formattedFiles, expectedFormattedFiles);
583 assert.equal(element._formattedFiles[1].value, element._path);
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]584 });
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]585
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]586 test('prev/up/next links', () => {
587 element._changeNum = '42';
588 element._patchRange = {
589 basePatchNum: PARENT,
590 patchNum: '10',
591 };
592 element._change = {
593 _number: 42,
594 revisions: {
Wyatt Allena744e232017-11-08 15:33:48 -0800[diff] [blame]595 a: {_number: 10, commit: {parents: []}},
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]596 },
597 };
598 element._fileList = ['chell.go', 'glados.txt', 'wheatley.md'];
599 element._path = 'glados.txt';
600 flushAsynchronousOperations();
601 const linkEls = Polymer.dom(element.root).querySelectorAll('.navLink');
602 assert.equal(linkEls.length, 3);
603 assert.equal(linkEls[0].getAttribute('href'), '42-chell.go-10-PARENT');
604 assert.equal(linkEls[1].getAttribute('href'), '42-undefined-undefined');
605 assert.equal(linkEls[2].getAttribute('href'),
606 '42-wheatley.md-10-PARENT');
607 element._path = 'wheatley.md';
608 flushAsynchronousOperations();
609 assert.equal(linkEls[0].getAttribute('href'),
610 '42-glados.txt-10-PARENT');
611 assert.equal(linkEls[1].getAttribute('href'), '42-undefined-undefined');
612 assert.isFalse(linkEls[2].hasAttribute('href'));
613 element._path = 'chell.go';
614 flushAsynchronousOperations();
615 assert.isFalse(linkEls[0].hasAttribute('href'));
616 assert.equal(linkEls[1].getAttribute('href'), '42-undefined-undefined');
617 assert.equal(linkEls[2].getAttribute('href'),
618 '42-glados.txt-10-PARENT');
619 element._path = 'not_a_real_file';
620 flushAsynchronousOperations();
621 assert.equal(linkEls[0].getAttribute('href'),
622 '42-wheatley.md-10-PARENT');
623 assert.equal(linkEls[1].getAttribute('href'), '42-undefined-undefined');
624 assert.equal(linkEls[2].getAttribute('href'), '42-chell.go-10-PARENT');
625 });
Andrew Bonventre8e375992016-02-25 11:51:15 -0500[diff] [blame]626
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]627 test('prev/up/next links with patch range', () => {
628 element._changeNum = '42';
629 element._patchRange = {
630 basePatchNum: '5',
631 patchNum: '10',
632 };
633 element._change = {
634 _number: 42,
635 revisions: {
Wyatt Allena744e232017-11-08 15:33:48 -0800[diff] [blame]636 a: {_number: 5, commit: {parents: []}},
637 b: {_number: 10, commit: {parents: []}},
Wyatt Allenc310f4f2017-07-05 21:26:33 -0700[diff] [blame]638 },
639 };
640 element._fileList = ['chell.go', 'glados.txt', 'wheatley.md'];
641 element._path = 'glados.txt';
642 flushAsynchronousOperations();
643 const linkEls = Polymer.dom(element.root).querySelectorAll('.navLink');
644 assert.equal(linkEls.length, 3);
645 assert.equal(linkEls[0].getAttribute('href'), '42-chell.go-10-5');
646 assert.equal(linkEls[1].getAttribute('href'), '42-10-5');
647 assert.equal(linkEls[2].getAttribute('href'), '42-wheatley.md-10-5');
648 element._path = 'wheatley.md';
649 flushAsynchronousOperations();
650 assert.equal(linkEls[0].getAttribute('href'), '42-glados.txt-10-5');
651 assert.equal(linkEls[1].getAttribute('href'), '42-10-5');
652 assert.isFalse(linkEls[2].hasAttribute('href'));
653 element._path = 'chell.go';
654 flushAsynchronousOperations();
655 assert.isFalse(linkEls[0].hasAttribute('href'));
656 assert.equal(linkEls[1].getAttribute('href'), '42-10-5');
657 assert.equal(linkEls[2].getAttribute('href'), '42-glados.txt-10-5');
658 });
Andrew Bonventre04e57d62016-09-07 17:34:41 -0400[diff] [blame]659 });
660
Becky Siegel89fe0502017-09-12 16:54:19 -0700[diff] [blame]661 test('_handlePatchChange calls navigateToDiff correctly', () => {
Becky Siegel89fe0502017-09-12 16:54:19 -0700[diff] [blame]662 const navigateStub = sandbox.stub(Gerrit.Nav, 'navigateToDiff');
663 element._change = {_number: 321, project: 'foo/bar'};
664 element._path = 'path/to/file.txt';
Becky Siegelfd7c71f2017-09-26 09:59:33 -0700[diff] [blame]665
666 element._patchRange = {
667 basePatchNum: 'PARENT',
668 patchNum: '3',
669 };
670
Becky Siegelaf950fd2017-10-12 11:35:18 -0700[diff] [blame]671 const detail = {
672 basePatchNum: 'PARENT',
673 patchNum: '1',
674 };
Becky Siegelfd7c71f2017-09-26 09:59:33 -0700[diff] [blame]675
Becky Siegelaf950fd2017-10-12 11:35:18 -0700[diff] [blame]676 element.$.rangeSelect.dispatchEvent(
677 new CustomEvent('patch-range-change', {detail, bubbles: false}));
Becky Siegel89fe0502017-09-12 16:54:19 -0700[diff] [blame]678
679 assert(navigateStub.lastCall.calledWithExactly(element._change,
Becky Siegelfd7c71f2017-09-26 09:59:33 -0700[diff] [blame]680 element._path, '1', 'PARENT'));
Becky Siegel89fe0502017-09-12 16:54:19 -0700[diff] [blame]681 });
682
Kasper Nilssonf428a232018-02-07 11:37:22 -0800[diff] [blame]683 test('_prefs.manual_review is respected', () => {
684 const saveReviewedStub = sandbox.stub(element, '_saveReviewedState',
685 () => Promise.resolve());
Kasper Nilsson03809372018-03-12 14:13:24 -0700[diff] [blame]686 const getReviewedStub = sandbox.stub(element, '_getReviewedStatus',
687 () => Promise.resolve());
Kasper Nilssonf428a232018-02-07 11:37:22 -0800[diff] [blame]688
Ole Rehmsene5de55e2018-08-23 16:52:57 +0200[diff] [blame]689 sandbox.stub(element.$.diffHost, 'reload');
Kasper Nilssonf428a232018-02-07 11:37:22 -0800[diff] [blame]690 element._loggedIn = true;
691 element.params = {
692 view: Gerrit.Nav.View.DIFF,
693 changeNum: '42',
694 patchNum: '2',
695 basePatchNum: '1',
696 path: '/COMMIT_MSG',
697 };
698 element._prefs = {manual_review: true};
699 flushAsynchronousOperations();
700
701 assert.isFalse(saveReviewedStub.called);
Kasper Nilsson03809372018-03-12 14:13:24 -0700[diff] [blame]702 assert.isTrue(getReviewedStub.called);
703
Kasper Nilssonf428a232018-02-07 11:37:22 -0800[diff] [blame]704 element._prefs = {};
705 flushAsynchronousOperations();
706
707 assert.isTrue(saveReviewedStub.called);
Kasper Nilsson03809372018-03-12 14:13:24 -0700[diff] [blame]708 assert.isTrue(getReviewedStub.calledOnce);
Kasper Nilssonf428a232018-02-07 11:37:22 -0800[diff] [blame]709 });
710
Kasper Nilssonb1e23072018-01-23 10:33:44 -0800[diff] [blame]711 test('file review status', () => {
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]712 const saveReviewedStub = sandbox.stub(element, '_saveReviewedState',
713 () => Promise.resolve());
Ole Rehmsene5de55e2018-08-23 16:52:57 +0200[diff] [blame]714 sandbox.stub(element.$.diffHost, 'reload');
Thomas Shafer88c17972017-06-26 15:13:03 -0700[diff] [blame]715
716 element._loggedIn = true;
717 element.params = {
Kasper Nilsson3c2e1212017-07-17 14:12:16 -0700[diff] [blame]718 view: Gerrit.Nav.View.DIFF,
Thomas Shafer88c17972017-06-26 15:13:03 -0700[diff] [blame]719 changeNum: '42',
720 patchNum: '2',
721 basePatchNum: '1',
722 path: '/COMMIT_MSG',
723 };
Kasper Nilssonf428a232018-02-07 11:37:22 -0800[diff] [blame]724 element._prefs = {};
Kasper Nilssonb1e23072018-01-23 10:33:44 -0800[diff] [blame]725 flushAsynchronousOperations();
Urs Wolfer51a70702016-02-10 21:59:20 +0100[diff] [blame]726
Kasper Nilssonb1e23072018-01-23 10:33:44 -0800[diff] [blame]727 const commitMsg = Polymer.dom(element.root).querySelector(
728 'input[type="checkbox"]');
Urs Wolfer51a70702016-02-10 21:59:20 +0100[diff] [blame]729
Kasper Nilssonb1e23072018-01-23 10:33:44 -0800[diff] [blame]730 assert.isTrue(commitMsg.checked);
731 MockInteractions.tap(commitMsg);
732 assert.isFalse(commitMsg.checked);
733 assert.isTrue(saveReviewedStub.lastCall.calledWithExactly(false));
Urs Wolfer51a70702016-02-10 21:59:20 +0100[diff] [blame]734
Kasper Nilssonb1e23072018-01-23 10:33:44 -0800[diff] [blame]735 MockInteractions.tap(commitMsg);
736 assert.isTrue(commitMsg.checked);
737 assert.isTrue(saveReviewedStub.lastCall.calledWithExactly(true));
738 const callCount = saveReviewedStub.callCount;
Urs Wolfer51a70702016-02-10 21:59:20 +0100[diff] [blame]739
Kasper Nilssonb1e23072018-01-23 10:33:44 -0800[diff] [blame]740 element.set('params.view', Gerrit.Nav.View.CHANGE);
741 flushAsynchronousOperations();
742
743 // saveReviewedState observer observes params, but should not fire when
744 // view !== Gerrit.Nav.View.DIFF.
745 assert.equal(saveReviewedStub.callCount, callCount);
Urs Wolfer51a70702016-02-10 21:59:20 +0100[diff] [blame]746 });
Wyatt Allenf93f1c242016-05-05 16:53:38 -0700[diff] [blame]747
Kasper Nilsson5f1f0c62017-08-08 14:04:54 -0700[diff] [blame]748 test('file review status with edit loaded', () => {
749 const saveReviewedStub = sandbox.stub(element, '_saveReviewedState');
750
751 element._patchRange = {patchNum: element.EDIT_NAME};
752 flushAsynchronousOperations();
753
Kasper Nilsson808838e2018-01-23 17:15:38 -0800[diff] [blame]754 assert.isTrue(element._editMode);
Kasper Nilsson5f1f0c62017-08-08 14:04:54 -0700[diff] [blame]755 element._setReviewed();
756 assert.isFalse(saveReviewedStub.called);
757 });
758
Kasper Nilsson3c2e1212017-07-17 14:12:16 -0700[diff] [blame]759 test('hash is determined from params', done => {
Ole Rehmsene5de55e2018-08-23 16:52:57 +0200[diff] [blame]760 sandbox.stub(element.$.diffHost, 'reload');
Wyatt Allenfd6a9472017-08-28 16:42:40 -0700[diff] [blame]761 sandbox.stub(element, '_initCursor');
Becky Siegel05d12532017-07-18 16:59:04 -0700[diff] [blame]762
763 element._loggedIn = true;
764 element.params = {
Kasper Nilsson3c2e1212017-07-17 14:12:16 -0700[diff] [blame]765 view: Gerrit.Nav.View.DIFF,
Becky Siegel05d12532017-07-18 16:59:04 -0700[diff] [blame]766 changeNum: '42',
767 patchNum: '2',
768 basePatchNum: '1',
769 path: '/COMMIT_MSG',
770 hash: 10,
771 };
772
773 flush(() => {
Wyatt Allenfd6a9472017-08-28 16:42:40 -0700[diff] [blame]774 assert.isTrue(element._initCursor.calledOnce);
Becky Siegel05d12532017-07-18 16:59:04 -0700[diff] [blame]775 done();
776 });
777 });
778
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]779 test('diff mode selector correctly toggles the diff', () => {
780 const select = element.$.modeSelect;
Ole Rehmsene5de55e2018-08-23 16:52:57 +0200[diff] [blame]781 const diffDisplay = element.$.diffHost;
Becky Siegel76ec5962016-12-09 16:58:31 -0800[diff] [blame]782 element._userPrefs = {default_diff_view: 'SIDE_BY_SIDE'};
Wyatt Allenf93f1c242016-05-05 16:53:38 -0700[diff] [blame]783
784 // The mode selected in the view state reflects the selected option.
Wyatt Allenffae7242018-02-14 15:58:17 -0800[diff] [blame]785 assert.equal(element._getDiffViewMode(), select.mode);
Wyatt Allenf93f1c242016-05-05 16:53:38 -0700[diff] [blame]786
787 // The mode selected in the view state reflects the view rednered in the
788 // diff.
Wyatt Allenffae7242018-02-14 15:58:17 -0800[diff] [blame]789 assert.equal(select.mode, diffDisplay.viewMode);
Wyatt Allenf93f1c242016-05-05 16:53:38 -0700[diff] [blame]790
791 // We will simulate a user change of the selected mode.
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]792 const newMode = 'UNIFIED_DIFF';
Wyatt Allenffae7242018-02-14 15:58:17 -0800[diff] [blame]793
794 // Set the mode, and simulate the change event.
795 element.set('changeViewState.diffMode', newMode);
Wyatt Allenf93f1c242016-05-05 16:53:38 -0700[diff] [blame]796
797 // Make sure the handler was called and the state is still coherent.
Wyatt Allenf93f1c242016-05-05 16:53:38 -0700[diff] [blame]798 assert.equal(element._getDiffViewMode(), newMode);
Wyatt Allenffae7242018-02-14 15:58:17 -0800[diff] [blame]799 assert.equal(element._getDiffViewMode(), select.mode);
Wyatt Allenf93f1c242016-05-05 16:53:38 -0700[diff] [blame]800 assert.equal(element._getDiffViewMode(), diffDisplay.viewMode);
Wyatt Allenf93f1c242016-05-05 16:53:38 -0700[diff] [blame]801 });
Wyatt Allenbdd4e342016-06-20 14:38:33 -0700[diff] [blame]802
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]803 test('diff mode selector initializes from preferences', () => {
804 let resolvePrefs;
805 const prefsPromise = new Promise(resolve => {
Logan Hanks78ad03c2016-08-25 12:35:50 -0700[diff] [blame]806 resolvePrefs = resolve;
807 });
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]808 sandbox.stub(element.$.restAPI, 'getPreferences', () => prefsPromise);
Logan Hanks78ad03c2016-08-25 12:35:50 -0700[diff] [blame]809
810 // Attach a new gr-diff-view so we can intercept the preferences fetch.
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]811 const view = document.createElement('gr-diff-view');
Logan Hanks78ad03c2016-08-25 12:35:50 -0700[diff] [blame]812 fixture('blank').appendChild(view);
813 flushAsynchronousOperations();
814
815 // At this point the diff mode doesn't yet have the user's preference.
Wyatt Allenffae7242018-02-14 15:58:17 -0800[diff] [blame]816 assert.equal(view._getDiffViewMode(), 'SIDE_BY_SIDE');
Logan Hanks78ad03c2016-08-25 12:35:50 -0700[diff] [blame]817
818 // Receive the overriding preference.
Becky Siegel76ec5962016-12-09 16:58:31 -0800[diff] [blame]819 resolvePrefs({default_diff_view: 'UNIFIED'});
Logan Hanks78ad03c2016-08-25 12:35:50 -0700[diff] [blame]820 flushAsynchronousOperations();
Wyatt Allenffae7242018-02-14 15:58:17 -0800[diff] [blame]821 assert.equal(element._getDiffViewMode(), 'SIDE_BY_SIDE');
Logan Hanks78ad03c2016-08-25 12:35:50 -0700[diff] [blame]822 });
823
Thomas Shafer849c4462018-02-05 12:05:38 -0800[diff] [blame]824 suite('_commitRange', () => {
825 setup(() => {
Ole Rehmsene5de55e2018-08-23 16:52:57 +0200[diff] [blame]826 sandbox.stub(element.$.diffHost, 'reload');
Thomas Shafer849c4462018-02-05 12:05:38 -0800[diff] [blame]827 sandbox.stub(element, '_initCursor');
828 sandbox.stub(element, '_getChangeDetail').returns(Promise.resolve({
829 _number: 42,
830 revisions: {
831 'commit-sha-1': {
832 _number: 1,
833 commit: {
834 parents: [{commit: 'sha-1-parent'}],
835 },
836 },
837 'commit-sha-2': {_number: 2},
838 'commit-sha-3': {_number: 3},
839 'commit-sha-4': {_number: 4},
840 'commit-sha-5': {
841 _number: 5,
842 commit: {
843 parents: [{commit: 'sha-5-parent'}],
844 },
845 },
846 },
847 }));
848 });
849
850 test('uses the patchNum and basePatchNum ', done => {
851 element.params = {
852 view: Gerrit.Nav.View.DIFF,
853 changeNum: '42',
854 patchNum: '4',
855 basePatchNum: '2',
856 path: '/COMMIT_MSG',
857 };
858 flush(() => {
859 assert.deepEqual(element._commitRange, {
860 baseCommit: 'commit-sha-2',
861 commit: 'commit-sha-4',
862 });
863 done();
864 });
865 });
866
867 test('uses the parent when there is no base patch num ', done => {
868 element.params = {
869 view: Gerrit.Nav.View.DIFF,
870 changeNum: '42',
871 patchNum: '5',
872 path: '/COMMIT_MSG',
873 };
874 flush(() => {
875 assert.deepEqual(element._commitRange, {
876 commit: 'commit-sha-5',
877 baseCommit: 'sha-5-parent',
878 });
879 done();
880 });
881 });
882 });
883
Wyatt Allenfd6a9472017-08-28 16:42:40 -0700[diff] [blame]884 test('_initCursor', () => {
Wyatt Allenbdd4e342016-06-20 14:38:33 -0700[diff] [blame]885 assert.isNotOk(element.$.cursor.initialLineNumber);
886
Wyatt Allenfd6a9472017-08-28 16:42:40 -0700[diff] [blame]887 // Does nothing when params specify no cursor address:
888 element._initCursor({});
Wyatt Allenbdd4e342016-06-20 14:38:33 -0700[diff] [blame]889 assert.isNotOk(element.$.cursor.initialLineNumber);
890
Wyatt Allenfd6a9472017-08-28 16:42:40 -0700[diff] [blame]891 // Does nothing when params specify side but no number:
892 element._initCursor({leftSide: true});
Becky Siegel05d12532017-07-18 16:59:04 -0700[diff] [blame]893 assert.isNotOk(element.$.cursor.initialLineNumber);
894
Wyatt Allenfd6a9472017-08-28 16:42:40 -0700[diff] [blame]895 // Revision hash: specifies lineNum but not side.
896 element._initCursor({lineNum: 234});
Wyatt Allenbdd4e342016-06-20 14:38:33 -0700[diff] [blame]897 assert.equal(element.$.cursor.initialLineNumber, 234);
898 assert.equal(element.$.cursor.side, 'right');
899
Wyatt Allenfd6a9472017-08-28 16:42:40 -0700[diff] [blame]900 // Base hash: specifies lineNum and side.
901 element._initCursor({leftSide: true, lineNum: 345});
Wyatt Allenbdd4e342016-06-20 14:38:33 -0700[diff] [blame]902 assert.equal(element.$.cursor.initialLineNumber, 345);
903 assert.equal(element.$.cursor.side, 'left');
Wyatt Allen4e1d1b82016-10-19 15:03:18 -0700[diff] [blame]904
Wyatt Allenfd6a9472017-08-28 16:42:40 -0700[diff] [blame]905 // Specifies right side:
906 element._initCursor({leftSide: false, lineNum: 123});
Wyatt Allen4e1d1b82016-10-19 15:03:18 -0700[diff] [blame]907 assert.equal(element.$.cursor.initialLineNumber, 123);
Wyatt Allenfd6a9472017-08-28 16:42:40 -0700[diff] [blame]908 assert.equal(element.$.cursor.side, 'right');
Wyatt Allenbdd4e342016-06-20 14:38:33 -0700[diff] [blame]909 });
Kasper Nilsson76aaa8c2016-09-27 15:57:56 -0700[diff] [blame]910
Wyatt Allene515ff62018-01-19 17:54:50 -0800[diff] [blame]911 test('_getLineOfInterest', () => {
912 assert.isNull(element._getLineOfInterest({}));
913
914 let result = element._getLineOfInterest({lineNum: 12});
915 assert.equal(result.number, 12);
916 assert.isNotOk(result.leftSide);
917
918 result = element._getLineOfInterest({lineNum: 12, leftSide: true});
919 assert.equal(result.number, 12);
920 assert.isOk(result.leftSide);
921 });
922
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]923 test('_onLineSelected', () => {
Wyatt Allenaea99742017-08-22 13:37:13 -0700[diff] [blame]924 const getUrlStub = sandbox.stub(Gerrit.Nav, 'getUrlForDiffById');
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]925 const replaceStateStub = sandbox.stub(history, 'replaceState');
926 const moveStub = sandbox.stub(element.$.cursor, 'moveToLineNumber');
Wyatt Allenaea99742017-08-22 13:37:13 -0700[diff] [blame]927 sandbox.stub(element.$.cursor, 'getAddress')
928 .returns({number: 123, isLeftSide: false});
Wyatt Allen43ddaf62016-10-26 17:11:50 -0700[diff] [blame]929
Wyatt Allenaea99742017-08-22 13:37:13 -0700[diff] [blame]930 element._changeNum = 321;
931 element._change = {_number: 321, project: 'foo/bar'};
932 element._patchRange = {
933 basePatchNum: '3',
934 patchNum: '5',
935 };
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]936 const e = {};
937 const detail = {number: 123, side: 'right'};
Wyatt Allen43ddaf62016-10-26 17:11:50 -0700[diff] [blame]938
939 element._onLineSelected(e, detail);
940
941 assert.isTrue(moveStub.called);
942 assert.equal(moveStub.lastCall.args[0], detail.number);
943 assert.equal(moveStub.lastCall.args[1], detail.side);
944
945 assert.isTrue(replaceStateStub.called);
Wyatt Allenaea99742017-08-22 13:37:13 -0700[diff] [blame]946 assert.isTrue(getUrlStub.called);
Wyatt Allen43ddaf62016-10-26 17:11:50 -0700[diff] [blame]947 });
Wyatt Allen20693de2016-11-01 16:11:07 -0700[diff] [blame]948
Wyatt Allen1bd466a2017-09-15 11:55:35 -0700[diff] [blame]949 test('_onLineSelected w/o line address', () => {
950 const getUrlStub = sandbox.stub(Gerrit.Nav, 'getUrlForDiffById');
951 sandbox.stub(history, 'replaceState');
952 sandbox.stub(element.$.cursor, 'moveToLineNumber');
953 sandbox.stub(element.$.cursor, 'getAddress').returns(null);
954 element._changeNum = 321;
955 element._change = {_number: 321, project: 'foo/bar'};
956 element._patchRange = {basePatchNum: '3', patchNum: '5'};
957 element._onLineSelected({}, {number: 123, side: 'right'});
958 assert.isTrue(getUrlStub.calledOnce);
959 assert.isUndefined(getUrlStub.lastCall.args[5]);
960 assert.isUndefined(getUrlStub.lastCall.args[6]);
961 });
962
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]963 test('_getDiffViewMode', () => {
Becky Siegel76ec5962016-12-09 16:58:31 -0800[diff] [blame]964 // No user prefs or change view state set.
965 assert.equal(element._getDiffViewMode(), 'SIDE_BY_SIDE');
966
967 // User prefs but no change view state set.
968 element._userPrefs = {default_diff_view: 'UNIFIED_DIFF'};
969 assert.equal(element._getDiffViewMode(), 'UNIFIED_DIFF');
970
971 // User prefs and change view state set.
972 element.changeViewState = {diffMode: 'SIDE_BY_SIDE'};
973 assert.equal(element._getDiffViewMode(), 'SIDE_BY_SIDE');
974 });
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]975
Logan Hanks5cde0842018-10-05 15:56:10 -0700[diff] [blame]976 test('_handleToggleDiffMode', () => {
Wyatt Allen61e414c2018-02-06 17:02:17 -0800[diff] [blame]977 sandbox.stub(element, 'shouldSuppressKeyboardShortcut').returns(false);
978 const e = {preventDefault: () => {}};
979 // Initial state.
980 assert.equal(element._getDiffViewMode(), 'SIDE_BY_SIDE');
981
Logan Hanks5cde0842018-10-05 15:56:10 -0700[diff] [blame]982 element._handleToggleDiffMode(e);
Wyatt Allen61e414c2018-02-06 17:02:17 -0800[diff] [blame]983 assert.equal(element._getDiffViewMode(), 'UNIFIED_DIFF');
984
Logan Hanks5cde0842018-10-05 15:56:10 -0700[diff] [blame]985 element._handleToggleDiffMode(e);
Wyatt Allen61e414c2018-02-06 17:02:17 -0800[diff] [blame]986 assert.equal(element._getDiffViewMode(), 'SIDE_BY_SIDE');
987 });
988
Wyatt Allendc8782d2017-07-26 09:32:03 -0700[diff] [blame]989 suite('_loadComments', () => {
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]990 test('empty', done => {
Wyatt Allendc8782d2017-07-26 09:32:03 -0700[diff] [blame]991 element._loadComments().then(() => {
992 assert.equal(Object.keys(element._commentMap).length, 0);
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]993 done();
994 });
995 });
996
Wyatt Allendc8782d2017-07-26 09:32:03 -0700[diff] [blame]997 test('has paths', done => {
Becky Siegelc7f07dc2017-11-02 16:07:13 -0700[diff] [blame]998 sandbox.stub(element, '_getPaths').returns({
999 'path/to/file/one.cpp': [{patch_set: 3, message: 'lorem'}],
1000 'path-to/file/two.py': [{patch_set: 5, message: 'ipsum'}],
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]1001 });
Becky Siegelc7f07dc2017-11-02 16:07:13 -0700[diff] [blame]1002 sandbox.stub(element, '_getCommentsForPath').returns({meta: {}});
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]1003 element._changeNum = '42';
1004 element._patchRange = {
1005 basePatchNum: '3',
1006 patchNum: '5',
1007 };
Wyatt Allendc8782d2017-07-26 09:32:03 -0700[diff] [blame]1008 element._loadComments().then(() => {
1009 assert.deepEqual(Object.keys(element._commentMap),
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]1010 ['path/to/file/one.cpp', 'path-to/file/two.py']);
1011 done();
1012 });
1013 });
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]1014 });
1015
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]1016 suite('_computeCommentSkips', () => {
1017 test('empty file list', () => {
1018 const commentMap = {
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]1019 'path/one.jpg': true,
1020 'path/three.wav': true,
1021 };
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]1022 const path = 'path/two.m4v';
1023 const fileList = [];
1024 const result = element._computeCommentSkips(commentMap, fileList, path);
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]1025 assert.isNull(result.previous);
1026 assert.isNull(result.next);
1027 });
1028
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]1029 test('finds skips', () => {
1030 const fileList = ['path/one.jpg', 'path/two.m4v', 'path/three.wav'];
1031 let path = fileList[1];
1032 const commentMap = {};
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]1033 commentMap[fileList[0]] = true;
1034 commentMap[fileList[1]] = false;
1035 commentMap[fileList[2]] = true;
1036
Kasper Nilssonef511942017-05-16 14:38:48 -0700[diff] [blame]1037 let result = element._computeCommentSkips(commentMap, fileList, path);
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]1038 assert.equal(result.previous, fileList[0]);
1039 assert.equal(result.next, fileList[2]);
1040
1041 commentMap[fileList[1]] = true;
1042
1043 result = element._computeCommentSkips(commentMap, fileList, path);
1044 assert.equal(result.previous, fileList[0]);
1045 assert.equal(result.next, fileList[2]);
1046
1047 path = fileList[0];
1048
1049 result = element._computeCommentSkips(commentMap, fileList, path);
1050 assert.isNull(result.previous);
1051 assert.equal(result.next, fileList[1]);
1052
1053 path = fileList[2];
1054
1055 result = element._computeCommentSkips(commentMap, fileList, path);
1056 assert.equal(result.previous, fileList[1]);
1057 assert.isNull(result.next);
1058 });
Wyatt Allen1b3eb9c2018-01-10 15:18:32 -0800[diff] [blame]1059
1060 suite('skip next/previous', () => {
1061 let navToChangeStub;
1062 let navToDiffStub;
1063
1064 setup(() => {
1065 navToChangeStub = sandbox.stub(element, '_navToChangeView');
1066 navToDiffStub = sandbox.stub(Gerrit.Nav, 'navigateToDiff');
1067 element._fileList = [
1068 'path/one.jpg', 'path/two.m4v', 'path/three.wav',
1069 ];
1070 element._patchRange = {patchNum: '2', basePatchNum: '1'};
1071 });
1072
1073 suite('_moveToPreviousFileWithComment', () => {
1074 test('no skips', () => {
1075 element._moveToPreviousFileWithComment();
1076 assert.isFalse(navToChangeStub.called);
1077 assert.isFalse(navToDiffStub.called);
1078 });
1079
1080 test('no previous', () => {
1081 const commentMap = {};
1082 commentMap[element._fileList[0]] = false;
1083 commentMap[element._fileList[1]] = false;
1084 commentMap[element._fileList[2]] = true;
1085 element._commentMap = commentMap;
1086 element._path = element._fileList[1];
1087
1088 element._moveToPreviousFileWithComment();
1089 assert.isTrue(navToChangeStub.calledOnce);
1090 assert.isFalse(navToDiffStub.called);
1091 });
1092
1093 test('w/ previous', () => {
1094 const commentMap = {};
1095 commentMap[element._fileList[0]] = true;
1096 commentMap[element._fileList[1]] = false;
1097 commentMap[element._fileList[2]] = true;
1098 element._commentMap = commentMap;
1099 element._path = element._fileList[1];
1100
1101 element._moveToPreviousFileWithComment();
1102 assert.isFalse(navToChangeStub.called);
1103 assert.isTrue(navToDiffStub.calledOnce);
1104 });
1105 });
1106
1107 suite('_moveToNextFileWithComment', () => {
1108 test('no skips', () => {
1109 element._moveToNextFileWithComment();
1110 assert.isFalse(navToChangeStub.called);
1111 assert.isFalse(navToDiffStub.called);
1112 });
1113
1114 test('no previous', () => {
1115 const commentMap = {};
1116 commentMap[element._fileList[0]] = true;
1117 commentMap[element._fileList[1]] = false;
1118 commentMap[element._fileList[2]] = false;
1119 element._commentMap = commentMap;
1120 element._path = element._fileList[1];
1121
1122 element._moveToNextFileWithComment();
1123 assert.isTrue(navToChangeStub.calledOnce);
1124 assert.isFalse(navToDiffStub.called);
1125 });
1126
1127 test('w/ previous', () => {
1128 const commentMap = {};
1129 commentMap[element._fileList[0]] = true;
1130 commentMap[element._fileList[1]] = false;
1131 commentMap[element._fileList[2]] = true;
1132 element._commentMap = commentMap;
1133 element._path = element._fileList[1];
1134
1135 element._moveToNextFileWithComment();
1136 assert.isFalse(navToChangeStub.called);
1137 assert.isTrue(navToDiffStub.calledOnce);
1138 });
1139 });
1140 });
Wyatt Allen1bc4f2f2017-01-18 17:10:51 -0800[diff] [blame]1141 });
Kasper Nilssonf89608d2017-07-24 15:06:07 -0700[diff] [blame]1142
Kasper Nilsson808838e2018-01-23 17:15:38 -0800[diff] [blame]1143 test('_computeEditMode', () => {
1144 const callCompute = range => element._computeEditMode({base: range});
Kasper Nilsson5f1f0c62017-08-08 14:04:54 -0700[diff] [blame]1145 assert.isFalse(callCompute({}));
1146 assert.isFalse(callCompute({basePatchNum: 'PARENT', patchNum: 1}));
1147 assert.isFalse(callCompute({basePatchNum: 'edit', patchNum: 1}));
1148 assert.isTrue(callCompute({basePatchNum: 1, patchNum: 'edit'}));
1149 });
1150
Viktar Donichc5069b12018-01-30 16:17:13 -0800[diff] [blame]1151 test('_computeFileNum', () => {
1152 assert.equal(element._computeFileNum('/foo',
1153 [{value: '/foo'}, {value: '/bar'}]), 1);
1154 assert.equal(element._computeFileNum('/bar',
1155 [{value: '/foo'}, {value: '/bar'}]), 2);
1156 });
1157
Wyatt Allen54ce5dc2018-03-06 11:27:36 -0800[diff] [blame]1158 test('_computeFileNumClass', () => {
1159 assert.equal(element._computeFileNumClass(0, []), '');
1160 assert.equal(element._computeFileNumClass(1,
1161 [{value: '/foo'}, {value: '/bar'}]), 'show');
Viktar Donichc5069b12018-01-30 16:17:13 -0800[diff] [blame]1162 });
1163
Kasper Nilsson03809372018-03-12 14:13:24 -0700[diff] [blame]1164 test('_getReviewedStatus', () => {
1165 const promises = [];
1166 element.$.restAPI.getReviewedFiles.restore();
1167
1168 sandbox.stub(element.$.restAPI, 'getReviewedFiles')
1169 .returns(Promise.resolve(['path']));
1170
1171 promises.push(element._getReviewedStatus(true, null, null, 'path')
1172 .then(reviewed => assert.isFalse(reviewed)));
1173
1174 promises.push(element._getReviewedStatus(false, null, null, 'otherPath')
1175 .then(reviewed => assert.isFalse(reviewed)));
1176
1177 promises.push(element._getReviewedStatus(false, null, null, 'path')
1178 .then(reviewed => assert.isTrue(reviewed)));
1179
1180 return Promise.all(promises);
1181 });
1182
Kasper Nilsson808838e2018-01-23 17:15:38 -0800[diff] [blame]1183 suite('editMode behavior', () => {
Kasper Nilsson5f1f0c62017-08-08 14:04:54 -0700[diff] [blame]1184 setup(() => {
1185 element._loggedIn = true;
1186 });
1187
1188 const isVisible = el => {
1189 assert.ok(el);
1190 return getComputedStyle(el).getPropertyValue('display') !== 'none';
1191 };
1192
1193 test('reviewed checkbox', () => {
Becky Siegelfd7c71f2017-09-26 09:59:33 -0700[diff] [blame]1194 sandbox.stub(element, '_handlePatchChange');
Kasper Nilsson5f1f0c62017-08-08 14:04:54 -0700[diff] [blame]1195 element._patchRange = {patchNum: '1'};
1196 // Reviewed checkbox should be shown.
1197 assert.isTrue(isVisible(element.$.reviewed));
1198 element.set('_patchRange.patchNum', element.EDIT_NAME);
1199 flushAsynchronousOperations();
1200
1201 assert.isFalse(isVisible(element.$.reviewed));
1202 });
1203 });
Kasper Nilsson34a5d892018-04-11 11:10:53 -0700[diff] [blame]1204
1205 test('_paramsChanged sets in projectLookup', () => {
1206 sandbox.stub(element, '_getLineOfInterest');
1207 sandbox.stub(element, '_initCursor');
1208 const setStub = sandbox.stub(element.$.restAPI, 'setInProjectLookup');
1209 element._paramsChanged({
1210 view: Gerrit.Nav.View.DIFF,
1211 changeNum: 101,
1212 project: 'test-project',
1213 path: '',
1214 });
1215 assert.isTrue(setStub.calledOnce);
1216 assert.isTrue(setStub.calledWith(101, 'test-project'));
1217 });
Kasper Nilsson30d54102018-11-12 10:55:29 -0800[diff] [blame]1218
1219 test('shift+m navigates to next unreviewed file', () => {
1220 element._fileList = ['file1', 'file2', 'file3'];
1221 element._reviewedFiles = new Set(['file1', 'file2']);
1222 element._path = 'file1';
1223 const reviewedStub = sandbox.stub(element, '_setReviewed');
1224 const navStub = sandbox.stub(element, '_navToFile');
1225 MockInteractions.pressAndReleaseKeyOn(element, 77, 'shift', 'm');
1226 flushAsynchronousOperations();
1227
1228 assert.isTrue(reviewedStub.lastCall.args[0]);
1229 assert.deepEqual(navStub.lastCall.args, [
1230 'file1',
1231 ['file1', 'file3'],
1232 1,
1233 ]);
1234 });
Paladox none45913eb2019-09-25 20:15:42 +0000[diff] [blame]1235
1236 test('_computeDownloadDropdownLinks', () => {
1237 const downloadLinks = [
1238 {
1239 url: '/changes/test~12/revisions/1/patch?zip&path=index.php',
1240 name: 'Patch',
1241 },
1242 {
1243 url: '/changes/test~12/revisions/1' +
1244 '/files/index.php/download?parent=1',
1245 name: 'Left Content',
1246 },
1247 {
1248 url: '/changes/test~12/revisions/1' +
Paladox noneb55da6e2019-10-06 13:33:54 +0000[diff] [blame]1249 '/files/index.php/download',
Paladox none45913eb2019-09-25 20:15:42 +0000[diff] [blame]1250 name: 'Right Content',
1251 },
1252 ];
Paladox noneb55da6e2019-10-06 13:33:54 +0000[diff] [blame]1253
1254 const side = {
1255 meta_a: true,
1256 meta_b: true,
1257 };
1258
1259 const base = {
1260 patchNum: 1,
1261 basePatchNum: 'PARENT',
1262 };
1263
Paladox none45913eb2019-09-25 20:15:42 +0000[diff] [blame]1264 assert.deepEqual(
1265 element._computeDownloadDropdownLinks(
Paladox noneb55da6e2019-10-06 13:33:54 +0000[diff] [blame]1266 'test', 12, base, 'index.php', side),
1267 downloadLinks);
1268 });
1269
1270 test('_computeDownloadDropdownLinks diff returns renamed', () => {
1271 const downloadLinks = [
1272 {
1273 url: '/changes/test~12/revisions/3/patch?zip&path=index.php',
1274 name: 'Patch',
1275 },
1276 {
1277 url: '/changes/test~12/revisions/2' +
1278 '/files/index2.php/download',
1279 name: 'Left Content',
1280 },
1281 {
1282 url: '/changes/test~12/revisions/3' +
1283 '/files/index.php/download',
1284 name: 'Right Content',
1285 },
1286 ];
1287
1288 const side = {
1289 change_type: 'RENAMED',
1290 meta_a: {
1291 name: 'index2.php',
1292 },
1293 meta_b: true,
1294 };
1295
1296 const base = {
1297 patchNum: 3,
1298 basePatchNum: 2,
1299 };
1300
1301 assert.deepEqual(
1302 element._computeDownloadDropdownLinks(
1303 'test', 12, base, 'index.php', side),
Paladox none45913eb2019-09-25 20:15:42 +0000[diff] [blame]1304 downloadLinks);
1305 });
1306
1307 test('_computeDownloadFileLink', () => {
Paladox noneb55da6e2019-10-06 13:33:54 +0000[diff] [blame]1308 const base = {
1309 patchNum: 1,
1310 basePatchNum: 'PARENT',
1311 };
1312
Paladox none45913eb2019-09-25 20:15:42 +0000[diff] [blame]1313 assert.equal(
1314 element._computeDownloadFileLink(
Paladox noneb55da6e2019-10-06 13:33:54 +0000[diff] [blame]1315 'test', 12, base, 'index.php', true),
Paladox none45913eb2019-09-25 20:15:42 +0000[diff] [blame]1316 '/changes/test~12/revisions/1/files/index.php/download?parent=1');
1317
1318 assert.equal(
1319 element._computeDownloadFileLink(
Paladox noneb55da6e2019-10-06 13:33:54 +0000[diff] [blame]1320 'test', 12, base, 'index.php', false),
1321 '/changes/test~12/revisions/1/files/index.php/download');
Paladox none45913eb2019-09-25 20:15:42 +0000[diff] [blame]1322 });
1323
1324 test('_computeDownloadPatchLink', () => {
1325 assert.equal(
1326 element._computeDownloadPatchLink(
1327 'test', 12, {patchNum: 1}, 'index.php'),
1328 '/changes/test~12/revisions/1/patch?zip&path=index.php');
1329 });
Andrew Bonventreab0f6a82015-11-14 15:40:47 -0500[diff] [blame]1330 });
1331</script>