<!DOCTYPE html>
<!--
@license
Copyright (C) 2015 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.
-->

<meta name="viewport" content="width=device-width, minimum-scale=1.0, initial-scale=1.0, user-scalable=yes">
<meta charset="utf-8">
<title>gr-change-view</title>

<script src="/node_modules/@webcomponents/webcomponentsjs/custom-elements-es5-adapter.js"></script>

<script src="/node_modules/@webcomponents/webcomponentsjs/webcomponents-lite.js"></script>
<script src="/components/wct-browser-legacy/browser.js"></script>
<script src="/node_modules/page/page.js"></script>

<test-fixture id="basic">
  <template>
    <gr-change-view></gr-change-view>
  </template>
</test-fixture>

<test-fixture id="blank">
  <template>
    <div></div>
  </template>
</test-fixture>

<script type="module">
import '../../../test/common-test-setup.js';
import '../../edit/gr-edit-constants.js';
import './gr-change-view.js';
import {PrimaryTabs, SecondaryTabs} from '../../../constants/constants.js';

import {dom} from '@polymer/polymer/lib/legacy/polymer.dom.js';
import {KeyboardShortcutBinder} from '../../../behaviors/keyboard-shortcut-behavior/keyboard-shortcut-behavior.js';
import {GrEditConstants} from '../../edit/gr-edit-constants.js';
import {_testOnly_resetEndpoints} from '../../shared/gr-js-api-interface/gr-plugin-endpoints.js';
import {util} from '../../../scripts/util.js';
import {GerritNav} from '../../core/gr-navigation/gr-navigation.js';
import {pluginLoader} from '../../shared/gr-js-api-interface/gr-plugin-loader.js';
import {_testOnly_initGerritPluginApi} from '../../shared/gr-js-api-interface/gr-gerrit.js';

const pluginApi = _testOnly_initGerritPluginApi();

suite('gr-change-view tests', () => {
  const kb = KeyboardShortcutBinder;
  kb.bindShortcut(kb.Shortcut.SEND_REPLY, 'ctrl+enter');
  kb.bindShortcut(kb.Shortcut.REFRESH_CHANGE, 'shift+r');
  kb.bindShortcut(kb.Shortcut.OPEN_REPLY_DIALOG, 'a');
  kb.bindShortcut(kb.Shortcut.OPEN_DOWNLOAD_DIALOG, 'd');
  kb.bindShortcut(kb.Shortcut.TOGGLE_DIFF_MODE, 'm');
  kb.bindShortcut(kb.Shortcut.TOGGLE_CHANGE_STAR, 's');
  kb.bindShortcut(kb.Shortcut.UP_TO_DASHBOARD, 'u');
  kb.bindShortcut(kb.Shortcut.EXPAND_ALL_MESSAGES, 'x');
  kb.bindShortcut(kb.Shortcut.COLLAPSE_ALL_MESSAGES, 'z');
  kb.bindShortcut(kb.Shortcut.OPEN_DIFF_PREFS, ',');
  kb.bindShortcut(kb.Shortcut.EDIT_TOPIC, 't');

  let element;
  let sandbox;
  let navigateToChangeStub;
  const TEST_SCROLL_TOP_PX = 100;

  const ROBOT_COMMENTS_LIMIT = 10;

  const THREADS = [
    {
      comments: [
        {
          __path: '/COMMIT_MSG',
          author: {
            _account_id: 1000000,
            name: 'user',
            username: 'user',
          },
          patch_set: 2,
          robot_id: 'rb1',
          id: 'ecf9fa_fe1a5f62',
          line: 5,
          updated: '2018-02-08 18:49:18.000000000',
          message: 'test',
          unresolved: true,
        },
        {
          __path: '/COMMIT_MSG',
          author: {
            _account_id: 1000000,
            name: 'user',
            username: 'user',
          },
          patch_set: 4,
          id: 'ecf0b9fa_fe1a5f62',
          line: 5,
          updated: '2018-02-08 18:49:18.000000000',
          message: 'test',
          unresolved: true,
        },
        {
          id: '503008e2_0ab203ee',
          path: '/COMMIT_MSG',
          line: 5,
          in_reply_to: 'ecf0b9fa_fe1a5f62',
          updated: '2018-02-13 22:48:48.018000000',
          message: 'draft',
          unresolved: false,
          __draft: true,
          __draftID: '0.m683trwff68',
          __editing: false,
          patch_set: '2',
        },
      ],
      patchNum: 4,
      path: '/COMMIT_MSG',
      line: 5,
      rootId: 'ecf0b9fa_fe1a5f62',
      start_datetime: '2018-02-08 18:49:18.000000000',
    },
    {
      comments: [
        {
          __path: '/COMMIT_MSG',
          author: {
            _account_id: 1000000,
            name: 'user',
            username: 'user',
          },
          patch_set: 3,
          id: 'ecf0b9fa_fe5f62',
          robot_id: 'rb2',
          line: 5,
          updated: '2018-02-08 18:49:18.000000000',
          message: 'test',
          unresolved: true,
        },
        {
          __path: 'test.txt',
          author: {
            _account_id: 1000000,
            name: 'user',
            username: 'user',
          },
          patch_set: 3,
          id: '09a9fb0a_1484e6cf',
          side: 'PARENT',
          updated: '2018-02-13 22:47:19.000000000',
          message: 'Some comment on another patchset.',
          unresolved: false,
        },
      ],
      patchNum: 3,
      path: 'test.txt',
      rootId: '09a9fb0a_1484e6cf',
      start_datetime: '2018-02-13 22:47:19.000000000',
      commentSide: 'PARENT',
    },
    {
      comments: [
        {
          __path: '/COMMIT_MSG',
          author: {
            _account_id: 1000000,
            name: 'user',
            username: 'user',
          },
          patch_set: 2,
          id: '8caddf38_44770ec1',
          line: 4,
          updated: '2018-02-13 22:48:40.000000000',
          message: 'Another unresolved comment',
          unresolved: true,
        },
      ],
      patchNum: 2,
      path: '/COMMIT_MSG',
      line: 4,
      rootId: '8caddf38_44770ec1',
      start_datetime: '2018-02-13 22:48:40.000000000',
    },
    {
      comments: [
        {
          __path: '/COMMIT_MSG',
          author: {
            _account_id: 1000000,
            name: 'user',
            username: 'user',
          },
          patch_set: 2,
          id: 'scaddf38_44770ec1',
          line: 4,
          updated: '2018-02-14 22:48:40.000000000',
          message: 'Yet another unresolved comment',
          unresolved: true,
        },
      ],
      patchNum: 2,
      path: '/COMMIT_MSG',
      line: 4,
      rootId: 'scaddf38_44770ec1',
      start_datetime: '2018-02-14 22:48:40.000000000',
    },
    {
      comments: [
        {
          id: 'zcf0b9fa_fe1a5f62',
          path: '/COMMIT_MSG',
          line: 6,
          updated: '2018-02-15 22:48:48.018000000',
          message: 'resolved draft',
          unresolved: false,
          __draft: true,
          __draftID: '0.m683trwff68',
          __editing: false,
          patch_set: '2',
        },
      ],
      patchNum: 4,
      path: '/COMMIT_MSG',
      line: 6,
      rootId: 'zcf0b9fa_fe1a5f62',
      start_datetime: '2018-02-09 18:49:18.000000000',
    },
    {
      comments: [
        {
          __path: '/COMMIT_MSG',
          author: {
            _account_id: 1000000,
            name: 'user',
            username: 'user',
          },
          patch_set: 4,
          id: 'rc1',
          line: 5,
          updated: '2019-02-08 18:49:18.000000000',
          message: 'test',
          unresolved: true,
          robot_id: 'rc1',
        },
      ],
      patchNum: 4,
      path: '/COMMIT_MSG',
      line: 5,
      rootId: 'rc1',
      start_datetime: '2019-02-08 18:49:18.000000000',
    },
    {
      comments: [
        {
          __path: '/COMMIT_MSG',
          author: {
            _account_id: 1000000,
            name: 'user',
            username: 'user',
          },
          patch_set: 4,
          id: 'rc2',
          line: 5,
          updated: '2019-03-08 18:49:18.000000000',
          message: 'test',
          unresolved: true,
          robot_id: 'rc2',
        },
        {
          __path: '/COMMIT_MSG',
          author: {
            _account_id: 1000000,
            name: 'user',
            username: 'user',
          },
          patch_set: 4,
          id: 'c2_1',
          line: 5,
          updated: '2019-03-08 18:49:18.000000000',
          message: 'test',
          unresolved: true,
        },
      ],
      patchNum: 4,
      path: '/COMMIT_MSG',
      line: 5,
      rootId: 'rc2',
      start_datetime: '2019-03-08 18:49:18.000000000',
    },
  ];

  setup(() => {
    sandbox = sinon.sandbox.create();
    stub('gr-endpoint-decorator', {
      _import: sandbox.stub().returns(Promise.resolve()),
    });
    // Since pluginEndpoints are global, must reset state.
    _testOnly_resetEndpoints();
    navigateToChangeStub = sandbox.stub(GerritNav, 'navigateToChange');
    stub('gr-rest-api-interface', {
      getConfig() { return Promise.resolve({test: 'config'}); },
      getAccount() { return Promise.resolve(null); },
      getDiffComments() { return Promise.resolve({}); },
      getDiffRobotComments() { return Promise.resolve({}); },
      getDiffDrafts() { return Promise.resolve({}); },
      _fetchSharedCacheURL() { return Promise.resolve({}); },
    });
    element = fixture('basic');
    sandbox.stub(element.$.actions, 'reload').returns(Promise.resolve());
    pluginLoader.loadPlugins([]);
    pluginApi.install(
        plugin => {
          plugin.registerDynamicCustomComponent(
              'change-view-tab-header',
              'gr-checks-change-view-tab-header-view'
          );
          plugin.registerDynamicCustomComponent(
              'change-view-tab-content',
              'gr-checks-view'
          );
        },
        '0.1',
        'http://some/plugins/url.html'
    );
  });

  teardown(done => {
    flush(() => {
      sandbox.restore();
      done();
    });
  });

  const getCustomCssValue =
      cssParam => util.getComputedStyleValue(cssParam, element);

  test('_handleMessageAnchorTap', () => {
    element._changeNum = '1';
    element._patchRange = {
      basePatchNum: 'PARENT',
      patchNum: 1,
    };
    const getUrlStub = sandbox.stub(GerritNav, 'getUrlForChange');
    const replaceStateStub = sandbox.stub(history, 'replaceState');
    element._handleMessageAnchorTap({detail: {id: 'a12345'}});

    assert.equal(getUrlStub.lastCall.args[4], '#message-a12345');
    assert.isTrue(replaceStateStub.called);
  });

  suite('plugins adding to file tab', () => {
    setup(done => {
      // Resolving it here instead of during setup() as other tests depend
      // on flush() not being called during setup.
      flush(() => done());
    });

    test('plugin added tab shows up as a dynamic endpoint', () => {
      assert(element._dynamicTabHeaderEndpoints.includes(
          'change-view-tab-header-url'));
      const paperTabs = element.shadowRoot.querySelector('#primaryTabs');
      // 3 Tabs are : Files, Plugin, Findings
      assert.equal(paperTabs.querySelectorAll('paper-tab').length, 3);
      assert.equal(paperTabs.querySelectorAll('paper-tab')[1].dataset.name,
          'change-view-tab-header-url');
    });

    test('_setActivePrimaryTab switched tab correctly', done => {
      element._setActivePrimaryTab({detail:
          {tab: 'change-view-tab-header-url'}});
      flush(() => {
        assert.equal(element._activeTabs[0], 'change-view-tab-header-url');
        done();
      });
    });

    test('show-primary-tab switched primary tab correctly', done => {
      element.fire('show-primary-tab', {tab: 'change-view-tab-header-url'});
      flush(() => {
        assert.equal(element._activeTabs[0], 'change-view-tab-header-url');
        done();
      });
    });

    test('param change should switch primary tab correctly', done => {
      assert.equal(element._activeTabs[0], PrimaryTabs.FILES);
      const queryMap = new Map();
      queryMap.set('tab', PrimaryTabs.FINDINGS);
      // view is required
      element.params = Object.assign(
          {
            view: GerritNav.View.CHANGE,
          },
          element.params, {queryMap});
      flush(() => {
        assert.equal(element._activeTabs[0], PrimaryTabs.FINDINGS);
        done();
      });
    });

    test('invalid param change should not switch primary tab', done => {
      assert.equal(element._activeTabs[0], PrimaryTabs.FILES);
      const queryMap = new Map();
      queryMap.set('tab', 'random');
      // view is required
      element.params = Object.assign(
          {
            view: GerritNav.View.CHANGE,
          },
          element.params, {queryMap});
      flush(() => {
        assert.equal(element._activeTabs[0], PrimaryTabs.FILES);
        done();
      });
    });

    test('switching tab sets _selectedTabPluginEndpoint', done => {
      const paperTabs = element.shadowRoot.querySelector('#primaryTabs');
      MockInteractions.tap(paperTabs.querySelectorAll('paper-tab')[1]);
      flush(() => {
        assert.equal(element._selectedTabPluginEndpoint,
            'change-view-tab-content-url');
        done();
      });
    });
  });

  suite('keyboard shortcuts', () => {
    test('t to add topic', () => {
      const editStub = sandbox.stub(element.$.metadata, 'editTopic');
      MockInteractions.pressAndReleaseKeyOn(element, 83, null, 't');
      assert(editStub.called);
    });

    test('S should toggle the CL star', () => {
      const starStub = sandbox.stub(element.$.changeStar, 'toggleStar');
      MockInteractions.pressAndReleaseKeyOn(element, 83, null, 's');
      assert(starStub.called);
    });

    test('U should navigate to root if no backPage set', () => {
      const relativeNavStub = sandbox.stub(GerritNav,
          'navigateToRelativeUrl');
      MockInteractions.pressAndReleaseKeyOn(element, 85, null, 'u');
      assert.isTrue(relativeNavStub.called);
      assert.isTrue(relativeNavStub.lastCall.calledWithExactly(
          GerritNav.getUrlForRoot()));
    });

    test('U should navigate to backPage if set', () => {
      const relativeNavStub = sandbox.stub(GerritNav,
          'navigateToRelativeUrl');
      element.backPage = '/dashboard/self';
      MockInteractions.pressAndReleaseKeyOn(element, 85, null, 'u');
      assert.isTrue(relativeNavStub.called);
      assert.isTrue(relativeNavStub.lastCall.calledWithExactly(
          '/dashboard/self'));
    });

    test('A fires an error event when not logged in', done => {
      sandbox.stub(element, '_getLoggedIn').returns(Promise.resolve(false));
      const loggedInErrorSpy = sandbox.spy();
      element.addEventListener('show-auth-required', loggedInErrorSpy);
      MockInteractions.pressAndReleaseKeyOn(element, 65, null, 'a');
      flush(() => {
        assert.isFalse(element.$.replyOverlay.opened);
        assert.isTrue(loggedInErrorSpy.called);
        done();
      });
    });

    test('shift A does not open reply overlay', done => {
      sandbox.stub(element, '_getLoggedIn').returns(Promise.resolve(true));
      MockInteractions.pressAndReleaseKeyOn(element, 65, 'shift', 'a');
      flush(() => {
        assert.isFalse(element.$.replyOverlay.opened);
        done();
      });
    });

    test('A toggles overlay when logged in', done => {
      sandbox.stub(element, '_getLoggedIn').returns(Promise.resolve(true));
      sandbox.stub(element.$.replyDialog, 'fetchChangeUpdates')
          .returns(Promise.resolve({isLatest: true}));
      element._change = {labels: {}};
      const openSpy = sandbox.spy(element, '_openReplyDialog');

      MockInteractions.pressAndReleaseKeyOn(element, 65, null, 'a');
      flush(() => {
        assert.isTrue(element.$.replyOverlay.opened);
        element.$.replyOverlay.close();
        assert.isFalse(element.$.replyOverlay.opened);
        assert(openSpy.lastCall.calledWithExactly(
            element.$.replyDialog.FocusTarget.ANY),
        '_openReplyDialog should have been passed ANY');
        assert.equal(openSpy.callCount, 1);
        done();
      });
    });

    test('fullscreen-overlay-opened hides content', () => {
      element._loggedIn = true;
      element._loading = false;
      element._change = {
        owner: {_account_id: 1},
        labels: {},
        actions: {
          abandon: {
            enabled: true,
            label: 'Abandon',
            method: 'POST',
            title: 'Abandon',
          },
        },
      };
      sandbox.spy(element, '_handleHideBackgroundContent');
      element.$.replyDialog.dispatchEvent(
          new CustomEvent('fullscreen-overlay-opened', {
            composed: true, bubbles: true,
          }));
      assert.isTrue(element._handleHideBackgroundContent.called);
      assert.isTrue(element.$.mainContent.classList.contains('overlayOpen'));
      assert.equal(getComputedStyle(element.$.actions).display, 'flex');
    });

    test('fullscreen-overlay-closed shows content', () => {
      element._loggedIn = true;
      element._loading = false;
      element._change = {
        owner: {_account_id: 1},
        labels: {},
        actions: {
          abandon: {
            enabled: true,
            label: 'Abandon',
            method: 'POST',
            title: 'Abandon',
          },
        },
      };
      sandbox.spy(element, '_handleShowBackgroundContent');
      element.$.replyDialog.dispatchEvent(
          new CustomEvent('fullscreen-overlay-closed', {
            composed: true, bubbles: true,
          }));
      assert.isTrue(element._handleShowBackgroundContent.called);
      assert.isFalse(element.$.mainContent.classList.contains('overlayOpen'));
    });

    test('expand all messages when expand-diffs fired', () => {
      const handleExpand =
          sandbox.stub(element.$.fileList, 'expandAllDiffs');
      element.$.fileListHeader.dispatchEvent(
          new CustomEvent('expand-diffs', {
            composed: true, bubbles: true,
          }));
      assert.isTrue(handleExpand.called);
    });

    test('collapse all messages when collapse-diffs fired', () => {
      const handleCollapse =
      sandbox.stub(element.$.fileList, 'collapseAllDiffs');
      element.$.fileListHeader.dispatchEvent(
          new CustomEvent('collapse-diffs', {
            composed: true, bubbles: true,
          }));
      assert.isTrue(handleCollapse.called);
    });

    test('X should expand all messages', done => {
      flush(() => {
        const handleExpand = sandbox.stub(element.messagesList,
            'handleExpandCollapse');
        MockInteractions.pressAndReleaseKeyOn(element, 88, null, 'x');
        assert(handleExpand.calledWith(true));
        done();
      });
    });

    test('Z should collapse all messages', done => {
      flush(() => {
        const handleExpand = sandbox.stub(element.messagesList,
            'handleExpandCollapse');
        MockInteractions.pressAndReleaseKeyOn(element, 90, null, 'z');
        assert(handleExpand.calledWith(false));
        done();
      });
    });

    test('shift + R should fetch and navigate to the latest patch set',
        done => {
          element._changeNum = '42';
          element._patchRange = {
            basePatchNum: 'PARENT',
            patchNum: 1,
          };
          element._change = {
            change_id: 'Iad9dc96274af6946f3632be53b106ef80f7ba6ca',
            _number: 42,
            revisions: {
              rev1: {_number: 1, commit: {parents: []}},
            },
            current_revision: 'rev1',
            status: 'NEW',
            labels: {},
            actions: {},
          };

          navigateToChangeStub.restore();
          navigateToChangeStub = sandbox.stub(GerritNav, 'navigateToChange',
              (change, patchNum, basePatchNum) => {
                assert.equal(change, element._change);
                assert.isUndefined(patchNum);
                assert.isUndefined(basePatchNum);
                done();
              });

          MockInteractions.pressAndReleaseKeyOn(element, 82, 'shift', 'r');
        });

    test('d should open download overlay', () => {
      const stub = sandbox.stub(element.$.downloadOverlay, 'open');
      MockInteractions.pressAndReleaseKeyOn(element, 68, null, 'd');
      assert.isTrue(stub.called);
    });

    test(', should open diff preferences', () => {
      const stub = sandbox.stub(
          element.$.fileList.$.diffPreferencesDialog, 'open');
      element._loggedIn = false;
      element.disableDiffPrefs = true;
      MockInteractions.pressAndReleaseKeyOn(element, 188, null, ',');
      assert.isFalse(stub.called);

      element._loggedIn = true;
      MockInteractions.pressAndReleaseKeyOn(element, 188, null, ',');
      assert.isFalse(stub.called);

      element.disableDiffPrefs = false;
      MockInteractions.pressAndReleaseKeyOn(element, 188, null, ',');
      assert.isTrue(stub.called);
    });

    test('m should toggle diff mode', () => {
      sandbox.stub(element, 'shouldSuppressKeyboardShortcut').returns(false);
      const setModeStub = sandbox.stub(element.$.fileListHeader,
          'setDiffViewMode');
      const e = {preventDefault: () => {}};
      flushAsynchronousOperations();

      element.viewState.diffMode = 'SIDE_BY_SIDE';
      element._handleToggleDiffMode(e);
      assert.isTrue(setModeStub.calledWith('UNIFIED_DIFF'));

      element.viewState.diffMode = 'UNIFIED_DIFF';
      element._handleToggleDiffMode(e);
      assert.isTrue(setModeStub.calledWith('SIDE_BY_SIDE'));
    });
  });

  suite('reloading drafts', () => {
    let reloadStub;
    const drafts = {
      'testfile.txt': [
        {
          patch_set: 5,
          id: 'dd2982f5_c01c9e6a',
          line: 1,
          updated: '2017-11-08 18:47:45.000000000',
          message: 'test',
          unresolved: true,
        },
      ],
    };
    setup(() => {
      // Fake computeDraftCount as its required for ChangeComments,
      // see gr-comment-api#reloadDrafts.
      reloadStub = sandbox.stub(element.$.commentAPI, 'reloadDrafts')
          .returns(Promise.resolve({
            drafts,
            getAllThreadsForChange: () => ([]),
            computeDraftCount: () => 1,
          }));
    });

    test('drafts are reloaded when reload-drafts fired', done => {
      element.$.fileList.dispatchEvent(
          new CustomEvent('reload-drafts', {
            detail: {
              resolve: () => {
                assert.isTrue(reloadStub.called);
                assert.deepEqual(element._diffDrafts, drafts);
                done();
              },
            },
            composed: true, bubbles: true,
          }));
    });

    test('drafts are reloaded when comment-refresh fired', () => {
      element.dispatchEvent(
          new CustomEvent('comment-refresh', {
            composed: true, bubbles: true,
          }));
      assert.isTrue(reloadStub.called);
    });
  });

  test('diff comments modified', () => {
    sandbox.spy(element, '_handleReloadCommentThreads');
    return element._reloadComments().then(() => {
      element.dispatchEvent(
          new CustomEvent('diff-comments-modified', {
            composed: true, bubbles: true,
          }));
      assert.isTrue(element._handleReloadCommentThreads.called);
    });
  });

  test('thread list modified', () => {
    sandbox.spy(element, '_handleReloadDiffComments');
    element._activeTabs = [PrimaryTabs.FILES, SecondaryTabs.COMMENT_THREADS];
    flushAsynchronousOperations();

    return element._reloadComments().then(() => {
      element.threadList.dispatchEvent(
          new CustomEvent('thread-list-modified', {
            composed: true, bubbles: true,
          }));
      assert.isTrue(element._handleReloadDiffComments.called);

      let draftStub = sinon.stub(element._changeComments, 'computeDraftCount')
          .returns(1);
      assert.equal(element._computeTotalCommentCounts(5,
          element._changeComments), '5 unresolved, 1 draft');
      assert.equal(element._computeTotalCommentCounts(0,
          element._changeComments), '1 draft');
      draftStub.restore();
      draftStub = sinon.stub(element._changeComments, 'computeDraftCount')
          .returns(0);
      assert.equal(element._computeTotalCommentCounts(0,
          element._changeComments), '');
      assert.equal(element._computeTotalCommentCounts(1,
          element._changeComments), '1 unresolved');
      draftStub.restore();
      draftStub = sinon.stub(element._changeComments, 'computeDraftCount')
          .returns(2);
      assert.equal(element._computeTotalCommentCounts(1,
          element._changeComments), '1 unresolved, 2 drafts');
      draftStub.restore();
    });
  });

  suite('thread list and change log tabs', () => {
    setup(() => {
      element._changeNum = '1';
      element._patchRange = {
        basePatchNum: 'PARENT',
        patchNum: 1,
      };
      element._change = {
        change_id: 'Iad9dc96274af6946f3632be53b106ef80f7ba6ca',
        revisions: {
          rev2: {_number: 2, commit: {parents: []}},
          rev1: {_number: 1, commit: {parents: []}},
          rev13: {_number: 13, commit: {parents: []}},
          rev3: {_number: 3, commit: {parents: []}},
        },
        current_revision: 'rev3',
        status: 'NEW',
        labels: {
          test: {
            all: [],
            default_value: 0,
            values: [],
            approved: {},
          },
        },
      };
      sandbox.stub(element.$.relatedChanges, 'reload');
      sandbox.stub(element, '_reload').returns(Promise.resolve());
      sandbox.spy(element, '_paramsChanged');
      element.params = {view: 'change', changeNum: '1'};
    });

    test('tab switch works correctly', done => {
      assert.isTrue(element._paramsChanged.called);
      assert.equal(element._activeTabs[1], SecondaryTabs.CHANGE_LOG);

      const commentTab = element.shadowRoot.querySelector(
          'paper-tab.commentThreads'
      );
      // Switch to comment thread tab
      MockInteractions.tap(commentTab);
      assert.equal(element._activeTabs[1], SecondaryTabs.COMMENT_THREADS);

      // Switch back to 'Change Log' tab
      element._paramsChanged(element.params);
      flush(() => {
        assert.equal(element._activeTabs[1], SecondaryTabs.CHANGE_LOG);
        done();
      });
    });

    test('show-secondary-tab event works', () => {
      assert.equal(element._activeTabs[1], SecondaryTabs.CHANGE_LOG);
      // Switch to comment thread tab
      element.fire('show-secondary-tab', {tab: SecondaryTabs.COMMENT_THREADS});
      assert.equal(element._activeTabs[1], SecondaryTabs.COMMENT_THREADS);
    });

    test('param change should switched secondary tab correctly', done => {
      assert.equal(element._activeTabs[1], SecondaryTabs.CHANGE_LOG);
      const queryMap = new Map();
      queryMap.set('secondaryTab', SecondaryTabs.COMMENT_THREADS);
      // view is required
      element.params = Object.assign(
          {view: GerritNav.View.CHANGE},
          element.params, {queryMap}
      );
      flush(() => {
        assert.equal(element._activeTabs[1], SecondaryTabs.COMMENT_THREADS);
        done();
      });
    });

    test('invalid secondaryTab should not switch tab', done => {
      assert.equal(element._activeTabs[1], SecondaryTabs.CHANGE_LOG);
      const queryMap = new Map();
      queryMap.set('secondaryTab', 'random');
      // view is required
      element.params = Object.assign({
        view: GerritNav.View.CHANGE,
      }, element.params, {queryMap});
      flush(() => {
        assert.equal(element._activeTabs[1], SecondaryTabs.CHANGE_LOG);
        done();
      });
    });
  });

  suite('Findings comment tab', () => {
    setup(done => {
      element._change = {
        change_id: 'Iad9dc96274af6946f3632be53b106ef80f7ba6ca',
        revisions: {
          rev2: {_number: 2, commit: {parents: []}},
          rev1: {_number: 1, commit: {parents: []}},
          rev13: {_number: 13, commit: {parents: []}},
          rev3: {_number: 3, commit: {parents: []}},
          rev4: {_number: 4, commit: {parents: []}},
        },
        current_revision: 'rev4',
      };
      element._commentThreads = THREADS;
      const paperTabs = element.shadowRoot.querySelector('#primaryTabs');
      MockInteractions.tap(paperTabs.querySelectorAll('paper-tab')[2]);
      flush(() => {
        done();
      });
    });

    test('robot comments count per patchset', () => {
      const count = element._robotCommentCountPerPatchSet(THREADS);
      const expectedCount = {
        2: 1,
        3: 1,
        4: 2,
      };
      assert.deepEqual(count, expectedCount);
      assert.equal(element._computeText({_number: 2}, THREADS),
          'Patchset 2 (1 finding)');
      assert.equal(element._computeText({_number: 4}, THREADS),
          'Patchset 4 (2 findings)');
      assert.equal(element._computeText({_number: 5}, THREADS),
          'Patchset 5');
    });

    test('only robot comments are rendered', () => {
      assert.equal(element._robotCommentThreads.length, 2);
      assert.equal(element._robotCommentThreads[0].comments[0].robot_id,
          'rc1');
      assert.equal(element._robotCommentThreads[1].comments[0].robot_id,
          'rc2');
    });

    test('changing patchsets resets robot comments', done => {
      element.set('_change.current_revision', 'rev3');
      flush(() => {
        assert.equal(element._robotCommentThreads.length, 1);
        done();
      });
    });

    test('Show more button is hidden', () => {
      assert.isNull(element.shadowRoot.querySelector('.show-robot-comments'));
    });

    suite('robot comments show more button', () => {
      setup(done => {
        const arr = [];
        for (let i = 0; i <= 30; i++) {
          arr.push(...THREADS);
        }
        element._commentThreads = arr;
        flush(() => {
          done();
        });
      });

      test('Show more button is rendered', () => {
        assert.isOk(element.shadowRoot.querySelector('.show-robot-comments'));
        assert.equal(element._robotCommentThreads.length,
            ROBOT_COMMENTS_LIMIT);
      });

      test('Clicking show more button renders all comments', done => {
        MockInteractions.tap(element.shadowRoot.querySelector(
            '.show-robot-comments'));
        flush(() => {
          assert.equal(element._robotCommentThreads.length, 62);
          done();
        });
      });
    });
  });

  test('reply button is not visible when logged out', () => {
    assert.equal(getComputedStyle(element.$.replyBtn).display, 'none');
    element._loggedIn = true;
    assert.notEqual(getComputedStyle(element.$.replyBtn).display, 'none');
  });

  test('download tap calls _handleOpenDownloadDialog', () => {
    sandbox.stub(element, '_handleOpenDownloadDialog');
    element.$.actions.dispatchEvent(
        new CustomEvent('download-tap', {
          composed: true, bubbles: true,
        }));
    assert.isTrue(element._handleOpenDownloadDialog.called);
  });

  test('fetches the server config on attached', done => {
    flush(() => {
      assert.equal(element._serverConfig.test, 'config');
      done();
    });
  });

  test('_changeStatuses', () => {
    sandbox.stub(element, 'changeStatuses').returns(
        ['Merged', 'WIP']);
    element._loading = false;
    element._change = {
      change_id: 'Iad9dc96274af6946f3632be53b106ef80f7ba6ca',
      revisions: {
        rev2: {_number: 2},
        rev1: {_number: 1},
        rev13: {_number: 13},
        rev3: {_number: 3},
      },
      current_revision: 'rev3',
      labels: {
        test: {
          all: [],
          default_value: 0,
          values: [],
          approved: {},
        },
      },
    };
    element._mergeable = true;
    const expectedStatuses = ['Merged', 'WIP'];
    assert.deepEqual(element._changeStatuses, expectedStatuses);
    assert.equal(element._changeStatus, expectedStatuses.join(', '));
    flushAsynchronousOperations();
    const statusChips = dom(element.root)
        .querySelectorAll('gr-change-status');
    assert.equal(statusChips.length, 2);
  });

  test('diff preferences open when open-diff-prefs is fired', () => {
    const overlayOpenStub = sandbox.stub(element.$.fileList,
        'openDiffPrefs');
    element.$.fileListHeader.dispatchEvent(
        new CustomEvent('open-diff-prefs', {
          composed: true, bubbles: true,
        }));
    assert.isTrue(overlayOpenStub.called);
  });

  test('_prepareCommitMsgForLinkify', () => {
    let commitMessage = 'R=test@google.com';
    let result = element._prepareCommitMsgForLinkify(commitMessage);
    assert.equal(result, 'R=\u200Btest@google.com');

    commitMessage = 'R=test@google.com\nR=test@google.com';
    result = element._prepareCommitMsgForLinkify(commitMessage);
    assert.equal(result, 'R=\u200Btest@google.com\nR=\u200Btest@google.com');

    commitMessage = 'CC=test@google.com';
    result = element._prepareCommitMsgForLinkify(commitMessage);
    assert.equal(result, 'CC=\u200Btest@google.com');
  }),

  test('_isSubmitEnabled', () => {
    assert.isFalse(element._isSubmitEnabled({}));
    assert.isFalse(element._isSubmitEnabled({submit: {}}));
    assert.isTrue(element._isSubmitEnabled(
        {submit: {enabled: true}}));
  });

  test('_reload is called when an approved label is removed', () => {
    const vote = {_account_id: 1, name: 'bojack', value: 1};
    element._changeNum = '42';
    element._patchRange = {
      basePatchNum: 'PARENT',
      patchNum: 1,
    };
    element._change = {
      change_id: 'Iad9dc96274af6946f3632be53b106ef80f7ba6ca',
      owner: {email: 'abc@def'},
      revisions: {
        rev2: {_number: 2, commit: {parents: []}},
        rev1: {_number: 1, commit: {parents: []}},
        rev13: {_number: 13, commit: {parents: []}},
        rev3: {_number: 3, commit: {parents: []}},
      },
      current_revision: 'rev3',
      status: 'NEW',
      labels: {
        test: {
          all: [vote],
          default_value: 0,
          values: [],
          approved: {},
        },
      },
    };
    flushAsynchronousOperations();
    const reloadStub = sandbox.stub(element, '_reload');
    element.splice('_change.labels.test.all', 0, 1);
    assert.isFalse(reloadStub.called);
    element._change.labels.test.all.push(vote);
    element._change.labels.test.all.push(vote);
    element._change.labels.test.approved = vote;
    flushAsynchronousOperations();
    element.splice('_change.labels.test.all', 0, 2);
    assert.isTrue(reloadStub.called);
    assert.isTrue(reloadStub.calledOnce);
  });

  test('reply button has updated count when there are drafts', () => {
    const getLabel = element._computeReplyButtonLabel;

    assert.equal(getLabel(null, false), 'Reply');
    assert.equal(getLabel(null, true), 'Start review');

    const changeRecord = {base: null};
    assert.equal(getLabel(changeRecord, false), 'Reply');

    changeRecord.base = {};
    assert.equal(getLabel(changeRecord, false), 'Reply');

    changeRecord.base = {
      'file1.txt': [{}],
      'file2.txt': [{}, {}],
    };
    assert.equal(getLabel(changeRecord, false), 'Reply (3)');
  });

  test('start review button when owner of WIP change', () => {
    assert.equal(
        element._computeReplyButtonLabel(null, true),
        'Start review');
  });

  test('comment events properly update diff drafts', () => {
    element._patchRange = {
      basePatchNum: 'PARENT',
      patchNum: 2,
    };
    const draft = {
      __draft: true,
      id: 'id1',
      path: '/foo/bar.txt',
      text: 'hello',
    };
    element._handleCommentSave({detail: {comment: draft}});
    draft.patch_set = 2;
    assert.deepEqual(element._diffDrafts, {'/foo/bar.txt': [draft]});
    draft.patch_set = null;
    draft.text = 'hello, there';
    element._handleCommentSave({detail: {comment: draft}});
    draft.patch_set = 2;
    assert.deepEqual(element._diffDrafts, {'/foo/bar.txt': [draft]});
    const draft2 = {
      __draft: true,
      id: 'id2',
      path: '/foo/bar.txt',
      text: 'hola',
    };
    element._handleCommentSave({detail: {comment: draft2}});
    draft2.patch_set = 2;
    assert.deepEqual(element._diffDrafts, {'/foo/bar.txt': [draft, draft2]});
    draft.patch_set = null;
    element._handleCommentDiscard({detail: {comment: draft}});
    draft.patch_set = 2;
    assert.deepEqual(element._diffDrafts, {'/foo/bar.txt': [draft2]});
    element._handleCommentDiscard({detail: {comment: draft2}});
    assert.deepEqual(element._diffDrafts, {});
  });

  test('change num change', () => {
    element._changeNum = null;
    element._patchRange = {
      basePatchNum: 'PARENT',
      patchNum: 2,
    };
    element._change = {
      change_id: 'Iad9dc96274af6946f3632be53b106ef80f7ba6ca',
      labels: {},
    };
    element.viewState.changeNum = null;
    element.viewState.diffMode = 'UNIFIED';
    assert.equal(element.viewState.numFilesShown, 200);
    assert.equal(element._numFilesShown, 200);
    element._numFilesShown = 150;
    flushAsynchronousOperations();
    assert.equal(element.viewState.diffMode, 'UNIFIED');
    assert.equal(element.viewState.numFilesShown, 150);

    element._changeNum = '1';
    element.params = {changeNum: '1'};
    element._change.newProp = '1';
    flushAsynchronousOperations();
    assert.equal(element.viewState.diffMode, 'UNIFIED');
    assert.equal(element.viewState.changeNum, '1');

    element._changeNum = '2';
    element.params = {changeNum: '2'};
    element._change.newProp = '2';
    flushAsynchronousOperations();
    assert.equal(element.viewState.diffMode, 'UNIFIED');
    assert.equal(element.viewState.changeNum, '2');
    assert.equal(element.viewState.numFilesShown, 200);
    assert.equal(element._numFilesShown, 200);
  });

  test('_setDiffViewMode is called with reset when new change is loaded',
      () => {
        sandbox.stub(element, '_setDiffViewMode');
        element.viewState = {changeNum: 1};
        element._changeNum = 2;
        element._resetFileListViewState();
        assert.isTrue(
            element._setDiffViewMode.lastCall.calledWithExactly(true));
      });

  test('diffViewMode is propagated from file list header', () => {
    element.viewState = {diffMode: 'UNIFIED'};
    element.$.fileListHeader.diffViewMode = 'SIDE_BY_SIDE';
    assert.equal(element.viewState.diffMode, 'SIDE_BY_SIDE');
  });

  test('diffMode defaults to side by side without preferences', done => {
    sandbox.stub(element.$.restAPI, 'getPreferences').returns(
        Promise.resolve({}));
    // No user prefs or diff view mode set.

    element._setDiffViewMode().then(() => {
      assert.equal(element.viewState.diffMode, 'SIDE_BY_SIDE');
      done();
    });
  });

  test('diffMode defaults to preference when not already set', done => {
    sandbox.stub(element.$.restAPI, 'getPreferences').returns(
        Promise.resolve({default_diff_view: 'UNIFIED'}));

    element._setDiffViewMode().then(() => {
      assert.equal(element.viewState.diffMode, 'UNIFIED');
      done();
    });
  });

  test('existing diffMode overrides preference', done => {
    element.viewState.diffMode = 'SIDE_BY_SIDE';
    sandbox.stub(element.$.restAPI, 'getPreferences').returns(
        Promise.resolve({default_diff_view: 'UNIFIED'}));
    element._setDiffViewMode().then(() => {
      assert.equal(element.viewState.diffMode, 'SIDE_BY_SIDE');
      done();
    });
  });

  test('don’t reload entire page when patchRange changes', () => {
    const reloadStub = sandbox.stub(element, '_reload',
        () => Promise.resolve());
    const reloadPatchDependentStub = sandbox.stub(element,
        '_reloadPatchNumDependentResources',
        () => Promise.resolve());
    const relatedClearSpy = sandbox.spy(element.$.relatedChanges, 'clear');
    const collapseStub = sandbox.stub(element.$.fileList, 'collapseAllDiffs');

    const value = {
      view: GerritNav.View.CHANGE,
      patchNum: '1',
    };
    element._paramsChanged(value);
    assert.isTrue(reloadStub.calledOnce);
    assert.isTrue(relatedClearSpy.calledOnce);

    element._initialLoadComplete = true;

    value.basePatchNum = '1';
    value.patchNum = '2';
    element._paramsChanged(value);
    assert.isFalse(reloadStub.calledTwice);
    assert.isTrue(reloadPatchDependentStub.calledOnce);
    assert.isTrue(relatedClearSpy.calledOnce);
    assert.isTrue(collapseStub.calledTwice);
  });

  test('reload entire page when patchRange doesnt change', () => {
    const reloadStub = sandbox.stub(element, '_reload',
        () => Promise.resolve());
    const collapseStub = sandbox.stub(element.$.fileList, 'collapseAllDiffs');
    const value = {
      view: GerritNav.View.CHANGE,
    };
    element._paramsChanged(value);
    assert.isTrue(reloadStub.calledOnce);
    element._initialLoadComplete = true;
    element._paramsChanged(value);
    assert.isTrue(reloadStub.calledTwice);
    assert.isTrue(collapseStub.calledTwice);
  });

  test('related changes are updated and new patch selected after rebase',
      done => {
        element._changeNum = '42';
        sandbox.stub(element, 'computeLatestPatchNum', () => 1);
        sandbox.stub(element, '_reload',
            () => Promise.resolve());
        const e = {detail: {action: 'rebase'}};
        element._handleReloadChange(e).then(() => {
          assert.isTrue(navigateToChangeStub.lastCall.calledWithExactly(
              element._change));
          done();
        });
      });

  test('related changes are not updated after other action', done => {
    sandbox.stub(element, '_reload', () => Promise.resolve());
    sandbox.stub(element.$.relatedChanges, 'reload');
    const e = {detail: {action: 'abandon'}};
    element._handleReloadChange(e).then(() => {
      assert.isFalse(navigateToChangeStub.called);
      done();
    });
  });

  test('_computeMergedCommitInfo', () => {
    const dummyRevs = {
      1: {commit: {commit: 1}},
      2: {commit: {}},
    };
    assert.deepEqual(element._computeMergedCommitInfo(0, dummyRevs), {});
    assert.deepEqual(element._computeMergedCommitInfo(1, dummyRevs),
        dummyRevs[1].commit);

    // Regression test for issue 5337.
    const commit = element._computeMergedCommitInfo(2, dummyRevs);
    assert.notDeepEqual(commit, dummyRevs[2]);
    assert.deepEqual(commit, {commit: 2});
  });

  test('_computeCopyTextForTitle', () => {
    const change = {
      _number: 123,
      subject: 'test subject',
      revisions: {
        rev1: {_number: 1},
        rev3: {_number: 3},
      },
      current_revision: 'rev3',
    };
    sandbox.stub(GerritNav, 'getUrlForChange')
        .returns('/change/123');
    assert.equal(
        element._computeCopyTextForTitle(change),
        `123: test subject | http://${location.host}/change/123`
    );
  });

  test('get latest revision', () => {
    let change = {
      revisions: {
        rev1: {_number: 1},
        rev3: {_number: 3},
      },
      current_revision: 'rev3',
    };
    assert.equal(element._getLatestRevisionSHA(change), 'rev3');
    change = {
      revisions: {
        rev1: {_number: 1},
      },
    };
    assert.equal(element._getLatestRevisionSHA(change), 'rev1');
  });

  test('show commit message edit button', () => {
    const _change = {
      status: element.ChangeStatus.MERGED,
    };
    assert.isTrue(element._computeHideEditCommitMessage(false, false, {}));
    assert.isTrue(element._computeHideEditCommitMessage(true, true, {}));
    assert.isTrue(element._computeHideEditCommitMessage(false, true, {}));
    assert.isFalse(element._computeHideEditCommitMessage(true, false, {}));
    assert.isTrue(element._computeHideEditCommitMessage(true, false,
        _change));
    assert.isTrue(element._computeHideEditCommitMessage(true, false, {},
        true));
    assert.isFalse(element._computeHideEditCommitMessage(true, false, {},
        false));
  });

  test('_handleCommitMessageSave trims trailing whitespace', () => {
    const putStub = sandbox.stub(element.$.restAPI, 'putChangeCommitMessage')
        .returns(Promise.resolve({}));

    const mockEvent = content => { return {detail: {content}}; };

    element._handleCommitMessageSave(mockEvent('test \n  test '));
    assert.equal(putStub.lastCall.args[1], 'test\n  test');

    element._handleCommitMessageSave(mockEvent('  test\ntest'));
    assert.equal(putStub.lastCall.args[1], '  test\ntest');

    element._handleCommitMessageSave(mockEvent('\n\n\n\n\n\n\n\n'));
    assert.equal(putStub.lastCall.args[1], '\n\n\n\n\n\n\n\n');
  });

  test('_computeChangeIdCommitMessageError', () => {
    let commitMessage =
      'Change-Id: I4ce18b2395bca69d7a9aa48bf4554faa56282483';
    let change = {change_id: 'I4ce18b2395bca69d7a9aa48bf4554faa56282483'};
    assert.equal(
        element._computeChangeIdCommitMessageError(commitMessage, change),
        null);

    change = {change_id: 'I4ce18b2395bca69d7a9aa48bf4554faa56282484'};
    assert.equal(
        element._computeChangeIdCommitMessageError(commitMessage, change),
        'mismatch');

    commitMessage = 'This is the greatest change.';
    assert.equal(
        element._computeChangeIdCommitMessageError(commitMessage, change),
        'missing');
  });

  test('multiple change Ids in commit message picks last', () => {
    const commitMessage = [
      'Change-Id: I4ce18b2395bca69d7a9aa48bf4554faa56282484',
      'Change-Id: I4ce18b2395bca69d7a9aa48bf4554faa56282483',
    ].join('\n');
    let change = {change_id: 'I4ce18b2395bca69d7a9aa48bf4554faa56282483'};
    assert.equal(
        element._computeChangeIdCommitMessageError(commitMessage, change),
        null);
    change = {change_id: 'I4ce18b2395bca69d7a9aa48bf4554faa56282484'};
    assert.equal(
        element._computeChangeIdCommitMessageError(commitMessage, change),
        'mismatch');
  });

  test('does not count change Id that starts mid line', () => {
    const commitMessage = [
      'Change-Id: I4ce18b2395bca69d7a9aa48bf4554faa56282484',
      'Change-Id: I4ce18b2395bca69d7a9aa48bf4554faa56282483',
    ].join(' and ');
    let change = {change_id: 'I4ce18b2395bca69d7a9aa48bf4554faa56282484'};
    assert.equal(
        element._computeChangeIdCommitMessageError(commitMessage, change),
        null);
    change = {change_id: 'I4ce18b2395bca69d7a9aa48bf4554faa56282483'};
    assert.equal(
        element._computeChangeIdCommitMessageError(commitMessage, change),
        'mismatch');
  });

  test('_computeTitleAttributeWarning', () => {
    let changeIdCommitMessageError = 'missing';
    assert.equal(
        element._computeTitleAttributeWarning(changeIdCommitMessageError),
        'No Change-Id in commit message');

    changeIdCommitMessageError = 'mismatch';
    assert.equal(
        element._computeTitleAttributeWarning(changeIdCommitMessageError),
        'Change-Id mismatch');
  });

  test('_computeChangeIdClass', () => {
    let changeIdCommitMessageError = 'missing';
    assert.equal(
        element._computeChangeIdClass(changeIdCommitMessageError), '');

    changeIdCommitMessageError = 'mismatch';
    assert.equal(
        element._computeChangeIdClass(changeIdCommitMessageError), 'warning');
  });

  test('topic is coalesced to null', done => {
    sandbox.stub(element, '_changeChanged');
    sandbox.stub(element.$.restAPI, 'getChangeDetail', () => Promise.resolve({
      id: '123456789',
      labels: {},
      current_revision: 'foo',
      revisions: {foo: {commit: {}}},
    }));

    element._getChangeDetail().then(() => {
      assert.isNull(element._change.topic);
      done();
    });
  });

  test('commit sha is populated from getChangeDetail', done => {
    sandbox.stub(element, '_changeChanged');
    sandbox.stub(element.$.restAPI, 'getChangeDetail', () => Promise.resolve({
      id: '123456789',
      labels: {},
      current_revision: 'foo',
      revisions: {foo: {commit: {}}},
    }));

    element._getChangeDetail().then(() => {
      assert.equal('foo', element._commitInfo.commit);
      done();
    });
  });

  test('edit is added to change', () => {
    sandbox.stub(element, '_changeChanged');
    sandbox.stub(element.$.restAPI, 'getChangeDetail', () => Promise.resolve({
      id: '123456789',
      labels: {},
      current_revision: 'foo',
      revisions: {foo: {commit: {}}},
    }));
    sandbox.stub(element, '_getEdit', () => Promise.resolve({
      base_patch_set_number: 1,
      commit: {commit: 'bar'},
    }));
    element._patchRange = {};

    return element._getChangeDetail().then(() => {
      const revs = element._change.revisions;
      assert.equal(Object.keys(revs).length, 2);
      assert.deepEqual(revs['foo'], {commit: {commit: 'foo'}});
      assert.deepEqual(revs['bar'], {
        _number: element.EDIT_NAME,
        basePatchNum: 1,
        commit: {commit: 'bar'},
        fetch: undefined,
      });
    });
  });

  test('_getBasePatchNum', () => {
    const _change = {
      _number: 42,
      revisions: {
        '98da160735fb81604b4c40e93c368f380539dd0e': {
          _number: 1,
          commit: {
            parents: [],
          },
        },
      },
    };
    const _patchRange = {
      basePatchNum: 'PARENT',
    };
    assert.equal(element._getBasePatchNum(_change, _patchRange), 'PARENT');

    element._prefs = {
      default_base_for_merges: 'FIRST_PARENT',
    };

    const _change2 = {
      _number: 42,
      revisions: {
        '98da160735fb81604b4c40e93c368f380539dd0e': {
          _number: 1,
          commit: {
            parents: [
              {
                commit: '6e12bdf1176eb4ab24d8491ba3b6d0704409cde8',
                subject: 'test',
              },
              {
                commit: '22f7db4754b5d9816fc581f3d9a6c0ef8429c841',
                subject: 'test3',
              },
            ],
          },
        },
      },
    };
    assert.equal(element._getBasePatchNum(_change2, _patchRange), -1);

    _patchRange.patchNum = 1;
    assert.equal(element._getBasePatchNum(_change2, _patchRange), 'PARENT');
  });

  test('_openReplyDialog called with `ANY` when coming from tap event',
      () => {
        const openStub = sandbox.stub(element, '_openReplyDialog');
        element._serverConfig = {};
        MockInteractions.tap(element.$.replyBtn);
        assert(openStub.lastCall.calledWithExactly(
            element.$.replyDialog.FocusTarget.ANY),
        '_openReplyDialog should have been passed ANY');
        assert.equal(openStub.callCount, 1);
      });

  test('_openReplyDialog called with `BODY` when coming from message reply' +
      'event', done => {
    flush(() => {
      const openStub = sandbox.stub(element, '_openReplyDialog');
      element.messagesList.dispatchEvent(
          new CustomEvent('reply', {
            detail:
          {message: {message: 'text'}},
            composed: true, bubbles: true,
          }));
      assert(openStub.lastCall.calledWithExactly(
          element.$.replyDialog.FocusTarget.BODY),
      '_openReplyDialog should have been passed BODY');
      assert.equal(openStub.callCount, 1);
      done();
    });
  });

  test('reply dialog focus can be controlled', () => {
    const FocusTarget = element.$.replyDialog.FocusTarget;
    const openStub = sandbox.stub(element, '_openReplyDialog');

    const e = {detail: {}};
    element._handleShowReplyDialog(e);
    assert(openStub.lastCall.calledWithExactly(FocusTarget.REVIEWERS),
        '_openReplyDialog should have been passed REVIEWERS');
    assert.equal(openStub.callCount, 1);

    e.detail.value = {ccsOnly: true};
    element._handleShowReplyDialog(e);
    assert(openStub.lastCall.calledWithExactly(FocusTarget.CCS),
        '_openReplyDialog should have been passed CCS');
    assert.equal(openStub.callCount, 2);
  });

  test('getUrlParameter functionality', () => {
    const locationStub = sandbox.stub(element, '_getLocationSearch');

    locationStub.returns('?test');
    assert.equal(element._getUrlParameter('test'), 'test');
    locationStub.returns('?test2=12&test=3');
    assert.equal(element._getUrlParameter('test'), 'test');
    locationStub.returns('');
    assert.isNull(element._getUrlParameter('test'));
    locationStub.returns('?');
    assert.isNull(element._getUrlParameter('test'));
    locationStub.returns('?test2');
    assert.isNull(element._getUrlParameter('test'));
  });

  test('revert dialog opened with revert param', done => {
    sandbox.stub(element.$.restAPI, 'getLoggedIn', () => Promise.resolve(true));
    sandbox.stub(pluginLoader, 'awaitPluginsLoaded', () => Promise.resolve());

    element._patchRange = {
      basePatchNum: 'PARENT',
      patchNum: 2,
    };
    element._change = {
      change_id: 'Iad9dc96274af6946f3632be53b106ef80f7ba6ca',
      revisions: {
        rev1: {_number: 1, commit: {parents: []}},
        rev2: {_number: 2, commit: {parents: []}},
      },
      current_revision: 'rev1',
      status: element.ChangeStatus.MERGED,
      labels: {},
      actions: {},
    };

    sandbox.stub(element, '_getUrlParameter',
        param => {
          assert.equal(param, 'revert');
          return param;
        });

    sandbox.stub(element.$.actions, 'showRevertDialog',
        done);

    element._maybeShowRevertDialog();
    assert.isTrue(pluginLoader.awaitPluginsLoaded.called);
  });

  suite('scroll related tests', () => {
    test('document scrolling calls function to set scroll height', done => {
      const originalHeight = document.body.scrollHeight;
      const scrollStub = sandbox.stub(element, '_handleScroll',
          () => {
            assert.isTrue(scrollStub.called);
            document.body.style.height = originalHeight + 'px';
            scrollStub.restore();
            done();
          });
      document.body.style.height = '10000px';
      element._handleScroll();
    });

    test('scrollTop is set correctly', () => {
      element.viewState = {scrollTop: TEST_SCROLL_TOP_PX};

      sandbox.stub(element, '_reload', () => {
        // When element is reloaded, ensure that the history
        // state has the scrollTop set earlier. This will then
        // be reset.
        assert.isTrue(element.viewState.scrollTop == TEST_SCROLL_TOP_PX);
        return Promise.resolve({});
      });

      // simulate reloading component, which is done when route
      // changes to match a regex of change view type.
      element._paramsChanged({view: GerritNav.View.CHANGE});
    });

    test('scrollTop is reset when new change is loaded', () => {
      element._resetFileListViewState();
      assert.equal(element.viewState.scrollTop, 0);
    });
  });

  suite('reply dialog tests', () => {
    setup(() => {
      sandbox.stub(element.$.replyDialog, '_draftChanged');
      sandbox.stub(element.$.replyDialog, 'fetchChangeUpdates',
          () => Promise.resolve({isLatest: true}));
      element._change = {labels: {}};
    });

    test('reply from comment adds quote text', () => {
      const e = {detail: {message: {message: 'quote text'}}};
      element._handleMessageReply(e);
      assert.equal(element.$.replyDialog.quote, '> quote text\n\n');
    });

    test('reply from comment replaces quote text', () => {
      element.$.replyDialog.draft = '> old quote text\n\n some draft text';
      element.$.replyDialog.quote = '> old quote text\n\n';
      const e = {detail: {message: {message: 'quote text'}}};
      element._handleMessageReply(e);
      assert.equal(element.$.replyDialog.quote, '> quote text\n\n');
    });

    test('reply from same comment preserves quote text', () => {
      element.$.replyDialog.draft = '> quote text\n\n some draft text';
      element.$.replyDialog.quote = '> quote text\n\n';
      const e = {detail: {message: {message: 'quote text'}}};
      element._handleMessageReply(e);
      assert.equal(element.$.replyDialog.draft,
          '> quote text\n\n some draft text');
      assert.equal(element.$.replyDialog.quote, '> quote text\n\n');
    });

    test('reply from top of page contains previous draft', () => {
      const div = document.createElement('div');
      element.$.replyDialog.draft = '> quote text\n\n some draft text';
      element.$.replyDialog.quote = '> quote text\n\n';
      const e = {target: div, preventDefault: sandbox.spy()};
      element._handleReplyTap(e);
      assert.equal(element.$.replyDialog.draft,
          '> quote text\n\n some draft text');
      assert.equal(element.$.replyDialog.quote, '> quote text\n\n');
    });
  });

  test('reply button is disabled until server config is loaded', () => {
    assert.isTrue(element._replyDisabled);
    element._serverConfig = {};
    assert.isFalse(element._replyDisabled);
  });

  suite('commit message expand/collapse', () => {
    setup(() => {
      sandbox.stub(element, 'fetchChangeUpdates',
          () => Promise.resolve({isLatest: false}));
    });

    test('commitCollapseToggle hidden for short commit message', () => {
      element._latestCommitMessage = '';
      assert.isTrue(element.$.commitCollapseToggle.hasAttribute('hidden'));
    });

    test('commitCollapseToggle shown for long commit message', () => {
      element._latestCommitMessage = _.times(31, String).join('\n');
      assert.isFalse(element.$.commitCollapseToggle.hasAttribute('hidden'));
    });

    test('commitCollapseToggle functions', () => {
      element._latestCommitMessage = _.times(35, String).join('\n');
      assert.isTrue(element._commitCollapsed);
      assert.isTrue(element._commitCollapsible);
      assert.isTrue(
          element.$.commitMessageEditor.hasAttribute('collapsed'));
      MockInteractions.tap(element.$.commitCollapseToggleButton);
      assert.isFalse(element._commitCollapsed);
      assert.isTrue(element._commitCollapsible);
      assert.isFalse(
          element.$.commitMessageEditor.hasAttribute('collapsed'));
    });
  });

  suite('related changes expand/collapse', () => {
    let updateHeightSpy;
    setup(() => {
      updateHeightSpy = sandbox.spy(element, '_updateRelatedChangeMaxHeight');
    });

    test('relatedChangesToggle shown height greater than changeInfo height',
        () => {
          assert.isFalse(element.$.relatedChangesToggle.classList
              .contains('showToggle'));
          sandbox.stub(element, '_getOffsetHeight', () => 50);
          sandbox.stub(element, '_getScrollHeight', () => 60);
          sandbox.stub(element, '_getLineHeight', () => 5);
          sandbox.stub(window, 'matchMedia', () => { return {matches: true}; });
          element.$.relatedChanges.dispatchEvent(
              new CustomEvent('new-section-loaded'));
          assert.isTrue(element.$.relatedChangesToggle.classList
              .contains('showToggle'));
          assert.equal(updateHeightSpy.callCount, 1);
        });

    test('relatedChangesToggle hidden height less than changeInfo height',
        () => {
          assert.isFalse(element.$.relatedChangesToggle.classList
              .contains('showToggle'));
          sandbox.stub(element, '_getOffsetHeight', () => 50);
          sandbox.stub(element, '_getScrollHeight', () => 40);
          sandbox.stub(element, '_getLineHeight', () => 5);
          sandbox.stub(window, 'matchMedia', () => { return {matches: true}; });
          element.$.relatedChanges.dispatchEvent(
              new CustomEvent('new-section-loaded'));
          assert.isFalse(element.$.relatedChangesToggle.classList
              .contains('showToggle'));
          assert.equal(updateHeightSpy.callCount, 1);
        });

    test('relatedChangesToggle functions', () => {
      sandbox.stub(element, '_getOffsetHeight', () => 50);
      sandbox.stub(window, 'matchMedia', () => { return {matches: false}; });
      element._relatedChangesLoading = false;
      assert.isTrue(element._relatedChangesCollapsed);
      assert.isTrue(
          element.$.relatedChanges.classList.contains('collapsed'));
      MockInteractions.tap(element.$.relatedChangesToggleButton);
      assert.isFalse(element._relatedChangesCollapsed);
      assert.isFalse(
          element.$.relatedChanges.classList.contains('collapsed'));
    });

    test('_updateRelatedChangeMaxHeight without commit toggle', () => {
      sandbox.stub(element, '_getOffsetHeight', () => 50);
      sandbox.stub(element, '_getLineHeight', () => 12);
      sandbox.stub(window, 'matchMedia', () => { return {matches: false}; });

      // 50 (existing height) - 30 (extra height) = 20 (adjusted height).
      // 20 (max existing height)  % 12 (line height) = 6 (remainder).
      // 20 (adjusted height) - 8 (remainder) = 12 (max height to set).

      element._updateRelatedChangeMaxHeight();
      assert.equal(getCustomCssValue('--relation-chain-max-height'),
          '12px');
      assert.equal(getCustomCssValue('--related-change-btn-top-padding'),
          '');
    });

    test('_updateRelatedChangeMaxHeight with commit toggle', () => {
      element._latestCommitMessage = _.times(31, String).join('\n');
      sandbox.stub(element, '_getOffsetHeight', () => 50);
      sandbox.stub(element, '_getLineHeight', () => 12);
      sandbox.stub(window, 'matchMedia', () => { return {matches: false}; });

      // 50 (existing height) % 12 (line height) = 2 (remainder).
      // 50 (existing height)  - 2 (remainder) = 48 (max height to set).

      element._updateRelatedChangeMaxHeight();
      assert.equal(getCustomCssValue('--relation-chain-max-height'),
          '48px');
      assert.equal(getCustomCssValue('--related-change-btn-top-padding'),
          '2px');
    });

    test('_updateRelatedChangeMaxHeight in small screen mode', () => {
      element._latestCommitMessage = _.times(31, String).join('\n');
      sandbox.stub(element, '_getOffsetHeight', () => 50);
      sandbox.stub(element, '_getLineHeight', () => 12);
      sandbox.stub(window, 'matchMedia', () => { return {matches: true}; });

      element._updateRelatedChangeMaxHeight();

      // 400 (new height) % 12 (line height) = 4 (remainder).
      // 400 (new height) - 4 (remainder) = 396.

      assert.equal(getCustomCssValue('--relation-chain-max-height'),
          '396px');
    });

    test('_updateRelatedChangeMaxHeight in medium screen mode', () => {
      element._latestCommitMessage = _.times(31, String).join('\n');
      sandbox.stub(element, '_getOffsetHeight', () => 50);
      sandbox.stub(element, '_getLineHeight', () => 12);
      sandbox.stub(window, 'matchMedia', () => {
        if (window.matchMedia.lastCall.args[0] === '(max-width: 75em)') {
          return {matches: true};
        } else {
          return {matches: false};
        }
      });

      // 100 (new height) % 12 (line height) = 4 (remainder).
      // 100 (new height) - 4 (remainder) = 96.
      element._updateRelatedChangeMaxHeight();
      assert.equal(getCustomCssValue('--relation-chain-max-height'),
          '96px');
    });

    suite('update checks', () => {
      setup(() => {
        sandbox.spy(element, '_startUpdateCheckTimer');
        sandbox.stub(element, 'async', f => {
          // Only fire the async callback one time.
          if (element.async.callCount > 1) { return; }
          f.call(element);
        });
      });

      test('_startUpdateCheckTimer negative delay', () => {
        sandbox.stub(element, 'fetchChangeUpdates');

        element._serverConfig = {change: {update_delay: -1}};

        assert.isTrue(element._startUpdateCheckTimer.called);
        assert.isFalse(element.fetchChangeUpdates.called);
      });

      test('_startUpdateCheckTimer up-to-date', () => {
        sandbox.stub(element, 'fetchChangeUpdates',
            () => Promise.resolve({isLatest: true}));

        element._serverConfig = {change: {update_delay: 12345}};

        assert.isTrue(element._startUpdateCheckTimer.called);
        assert.isTrue(element.fetchChangeUpdates.called);
        assert.equal(element.async.lastCall.args[1], 12345 * 1000);
      });

      test('_startUpdateCheckTimer out-of-date shows an alert', done => {
        sandbox.stub(element, 'fetchChangeUpdates',
            () => Promise.resolve({isLatest: false}));
        element.addEventListener('show-alert', e => {
          assert.equal(e.detail.message,
              'A newer patch set has been uploaded');
          done();
        });
        element._serverConfig = {change: {update_delay: 12345}};
      });

      test('_startUpdateCheckTimer new status shows an alert', done => {
        sandbox.stub(element, 'fetchChangeUpdates')
            .returns(Promise.resolve({
              isLatest: true,
              newStatus: element.ChangeStatus.MERGED,
            }));
        element.addEventListener('show-alert', e => {
          assert.equal(e.detail.message, 'This change has been merged');
          done();
        });
        element._serverConfig = {change: {update_delay: 12345}};
      });

      test('_startUpdateCheckTimer new messages shows an alert', done => {
        sandbox.stub(element, 'fetchChangeUpdates')
            .returns(Promise.resolve({
              isLatest: true,
              newMessages: true,
            }));
        element.addEventListener('show-alert', e => {
          assert.equal(e.detail.message,
              'There are new messages on this change');
          done();
        });
        element._serverConfig = {change: {update_delay: 12345}};
      });
    });

    test('canStartReview computation', () => {
      const change1 = {};
      const change2 = {
        actions: {
          ready: {
            enabled: true,
          },
        },
      };
      const change3 = {
        actions: {
          ready: {
            label: 'Ready for Review',
          },
        },
      };
      assert.isFalse(element._computeCanStartReview(change1));
      assert.isTrue(element._computeCanStartReview(change2));
      assert.isFalse(element._computeCanStartReview(change3));
    });
  });

  test('header class computation', () => {
    assert.equal(element._computeHeaderClass(), 'header');
    assert.equal(element._computeHeaderClass(true), 'header editMode');
  });

  test('_maybeScrollToMessage', done => {
    flush(() => {
      const scrollStub = sandbox.stub(element.messagesList,
          'scrollToMessage');

      element._maybeScrollToMessage('');
      assert.isFalse(scrollStub.called);
      element._maybeScrollToMessage('message');
      assert.isFalse(scrollStub.called);
      element._maybeScrollToMessage('#message-TEST');
      assert.isTrue(scrollStub.called);
      assert.equal(scrollStub.lastCall.args[0], 'TEST');
      done();
    });
  });

  test('topic update reloads related changes', () => {
    sandbox.stub(element.$.relatedChanges, 'reload');
    element.dispatchEvent(new CustomEvent('topic-changed'));
    assert.isTrue(element.$.relatedChanges.reload.calledOnce);
  });

  test('_computeEditMode', () => {
    const callCompute = (range, params) =>
      element._computeEditMode({base: range}, {base: params});
    assert.isFalse(callCompute({}, {}));
    assert.isTrue(callCompute({}, {edit: true}));
    assert.isFalse(callCompute({basePatchNum: 'PARENT', patchNum: 1}, {}));
    assert.isFalse(callCompute({basePatchNum: 'edit', patchNum: 1}, {}));
    assert.isTrue(callCompute({basePatchNum: 1, patchNum: 'edit'}, {}));
  });

  test('_processEdit', () => {
    element._patchRange = {};
    const change = {
      current_revision: 'foo',
      revisions: {foo: {commit: {}, actions: {cherrypick: {enabled: true}}}},
    };
    let mockChange;

    // With no edit, mockChange should be unmodified.
    element._processEdit(mockChange = _.cloneDeep(change), null);
    assert.deepEqual(mockChange, change);

    // When edit is not based on the latest PS, current_revision should be
    // unmodified.
    const edit = {
      base_patch_set_number: 1,
      commit: {commit: 'bar'},
      fetch: true,
    };
    element._processEdit(mockChange = _.cloneDeep(change), edit);
    assert.notDeepEqual(mockChange, change);
    assert.equal(mockChange.revisions.bar._number, element.EDIT_NAME);
    assert.equal(mockChange.current_revision, change.current_revision);
    assert.deepEqual(mockChange.revisions.bar.commit, {commit: 'bar'});
    assert.notOk(mockChange.revisions.bar.actions);

    edit.base_revision = 'foo';
    element._processEdit(mockChange = _.cloneDeep(change), edit);
    assert.notDeepEqual(mockChange, change);
    assert.equal(mockChange.current_revision, 'bar');
    assert.deepEqual(mockChange.revisions.bar.actions,
        mockChange.revisions.foo.actions);

    // If _patchRange.patchNum is defined, do not load edit.
    element._patchRange.patchNum = 'baz';
    change.current_revision = 'baz';
    element._processEdit(mockChange = _.cloneDeep(change), edit);
    assert.equal(element._patchRange.patchNum, 'baz');
    assert.notOk(mockChange.revisions.bar.actions);
  });

  test('file-action-tap handling', () => {
    element._patchRange = {
      basePatchNum: 'PARENT',
      patchNum: 1,
    };
    const fileList = element.$.fileList;
    const Actions = GrEditConstants.Actions;
    const controls = element.$.fileListHeader.$.editControls;
    sandbox.stub(controls, 'openDeleteDialog');
    sandbox.stub(controls, 'openRenameDialog');
    sandbox.stub(controls, 'openRestoreDialog');
    sandbox.stub(GerritNav, 'getEditUrlForDiff');
    sandbox.stub(GerritNav, 'navigateToRelativeUrl');

    // Delete
    fileList.dispatchEvent(new CustomEvent('file-action-tap', {
      detail: {action: Actions.DELETE.id, path: 'foo'},
      bubbles: true,
      composed: true,
    }));
    flushAsynchronousOperations();

    assert.isTrue(controls.openDeleteDialog.called);
    assert.equal(controls.openDeleteDialog.lastCall.args[0], 'foo');

    // Restore
    fileList.dispatchEvent(new CustomEvent('file-action-tap', {
      detail: {action: Actions.RESTORE.id, path: 'foo'},
      bubbles: true,
      composed: true,
    }));
    flushAsynchronousOperations();

    assert.isTrue(controls.openRestoreDialog.called);
    assert.equal(controls.openRestoreDialog.lastCall.args[0], 'foo');

    // Rename
    fileList.dispatchEvent(new CustomEvent('file-action-tap', {
      detail: {action: Actions.RENAME.id, path: 'foo'},
      bubbles: true,
      composed: true,
    }));
    flushAsynchronousOperations();

    assert.isTrue(controls.openRenameDialog.called);
    assert.equal(controls.openRenameDialog.lastCall.args[0], 'foo');

    // Open
    fileList.dispatchEvent(new CustomEvent('file-action-tap', {
      detail: {action: Actions.OPEN.id, path: 'foo'},
      bubbles: true,
      composed: true,
    }));
    flushAsynchronousOperations();

    assert.isTrue(GerritNav.getEditUrlForDiff.called);
    assert.equal(GerritNav.getEditUrlForDiff.lastCall.args[1], 'foo');
    assert.equal(GerritNav.getEditUrlForDiff.lastCall.args[2], '1');
    assert.isTrue(GerritNav.navigateToRelativeUrl.called);
  });

  test('_selectedRevision updates when patchNum is changed', () => {
    const revision1 = {_number: 1, commit: {parents: []}};
    const revision2 = {_number: 2, commit: {parents: []}};
    sandbox.stub(element.$.restAPI, 'getChangeDetail').returns(
        Promise.resolve({
          revisions: {
            aaa: revision1,
            bbb: revision2,
          },
          labels: {},
          actions: {},
          current_revision: 'bbb',
          change_id: 'loremipsumdolorsitamet',
        }));
    sandbox.stub(element, '_getEdit').returns(Promise.resolve());
    sandbox.stub(element, '_getPreferences').returns(Promise.resolve({}));
    element._patchRange = {patchNum: '2'};
    return element._getChangeDetail().then(() => {
      assert.strictEqual(element._selectedRevision, revision2);

      element.set('_patchRange.patchNum', '1');
      assert.strictEqual(element._selectedRevision, revision1);
    });
  });

  test('_selectedRevision is assigned when patchNum is edit', () => {
    const revision1 = {_number: 1, commit: {parents: []}};
    const revision2 = {_number: 2, commit: {parents: []}};
    const revision3 = {_number: 'edit', commit: {parents: []}};
    sandbox.stub(element.$.restAPI, 'getChangeDetail').returns(
        Promise.resolve({
          revisions: {
            aaa: revision1,
            bbb: revision2,
            ccc: revision3,
          },
          labels: {},
          actions: {},
          current_revision: 'ccc',
          change_id: 'loremipsumdolorsitamet',
        }));
    sandbox.stub(element, '_getEdit').returns(Promise.resolve());
    sandbox.stub(element, '_getPreferences').returns(Promise.resolve({}));
    element._patchRange = {patchNum: 'edit'};
    return element._getChangeDetail().then(() => {
      assert.strictEqual(element._selectedRevision, revision3);
    });
  });

  test('_sendShowChangeEvent', () => {
    element._change = {labels: {}};
    element._patchRange = {patchNum: 4};
    element._mergeable = true;
    const showStub = sandbox.stub(element.$.jsAPI, 'handleEvent');
    element._sendShowChangeEvent();
    assert.isTrue(showStub.calledOnce);
    assert.equal(
        showStub.lastCall.args[0], element.$.jsAPI.EventType.SHOW_CHANGE);
    assert.deepEqual(showStub.lastCall.args[1], {
      change: {labels: {}},
      patchNum: 4,
      info: {mergeable: true},
    });
  });

  suite('_handleEditTap', () => {
    let fireEdit;

    setup(() => {
      fireEdit = () => {
        element.$.actions.dispatchEvent(new CustomEvent('edit-tap'));
      };
      navigateToChangeStub.restore();

      element._change = {revisions: {rev1: {_number: 1}}};
    });

    test('edit exists in revisions', done => {
      sandbox.stub(GerritNav, 'navigateToChange', (...args) => {
        assert.equal(args.length, 2);
        assert.equal(args[1], element.EDIT_NAME); // patchNum
        done();
      });

      element.set('_change.revisions.rev2', {_number: element.EDIT_NAME});
      flushAsynchronousOperations();

      fireEdit();
    });

    test('no edit exists in revisions, non-latest patchset', done => {
      sandbox.stub(GerritNav, 'navigateToChange', (...args) => {
        assert.equal(args.length, 4);
        assert.equal(args[1], 1); // patchNum
        assert.equal(args[3], true); // opt_isEdit
        done();
      });

      element.set('_change.revisions.rev2', {_number: 2});
      element._patchRange = {patchNum: 1};
      flushAsynchronousOperations();

      fireEdit();
    });

    test('no edit exists in revisions, latest patchset', done => {
      sandbox.stub(GerritNav, 'navigateToChange', (...args) => {
        assert.equal(args.length, 4);
        // No patch should be specified when patchNum == latest.
        assert.isNotOk(args[1]); // patchNum
        assert.equal(args[3], true); // opt_isEdit
        done();
      });

      element.set('_change.revisions.rev2', {_number: 2});
      element._patchRange = {patchNum: 2};
      flushAsynchronousOperations();

      fireEdit();
    });
  });

  test('_handleStopEditTap', done => {
    sandbox.stub(element.$.metadata, '_computeLabelNames');
    navigateToChangeStub.restore();
    sandbox.stub(element, 'computeLatestPatchNum').returns(1);
    sandbox.stub(GerritNav, 'navigateToChange', (...args) => {
      assert.equal(args.length, 2);
      assert.equal(args[1], 1); // patchNum
      done();
    });

    element._patchRange = {patchNum: 1};
    element.$.actions.dispatchEvent(new CustomEvent('stop-edit-tap',
        {bubbles: false}));
  });

  suite('plugin endpoints', () => {
    test('endpoint params', done => {
      element._change = {labels: {}};
      element._selectedRevision = {};
      let hookEl;
      let plugin;
      pluginApi.install(
          p => {
            plugin = p;
            plugin.hook('change-view-integration').getLastAttached()
                .then(
                    el => hookEl = el);
          },
          '0.1',
          'http://some/plugins/url.html');
      flush(() => {
        assert.strictEqual(hookEl.plugin, plugin);
        assert.strictEqual(hookEl.change, element._change);
        assert.strictEqual(hookEl.revision, element._selectedRevision);
        done();
      });
    });
  });

  suite('_getMergeability', () => {
    let getMergeableStub;

    setup(() => {
      element._change = {labels: {}};
      getMergeableStub = sandbox.stub(element.$.restAPI, 'getMergeable')
          .returns(Promise.resolve({mergeable: true}));
    });

    test('merged change', () => {
      element._mergeable = null;
      element._change.status = element.ChangeStatus.MERGED;
      return element._getMergeability().then(() => {
        assert.isFalse(element._mergeable);
        assert.isFalse(getMergeableStub.called);
      });
    });

    test('abandoned change', () => {
      element._mergeable = null;
      element._change.status = element.ChangeStatus.ABANDONED;
      return element._getMergeability().then(() => {
        assert.isFalse(element._mergeable);
        assert.isFalse(getMergeableStub.called);
      });
    });

    test('open change', () => {
      element._mergeable = null;
      return element._getMergeability().then(() => {
        assert.isTrue(element._mergeable);
        assert.isTrue(getMergeableStub.called);
      });
    });
  });

  test('_paramsChanged sets in projectLookup', () => {
    sandbox.stub(element.$.relatedChanges, 'reload');
    sandbox.stub(element, '_reload').returns(Promise.resolve());
    const setStub = sandbox.stub(element.$.restAPI, 'setInProjectLookup');
    element._paramsChanged({
      view: GerritNav.View.CHANGE,
      changeNum: 101,
      project: 'test-project',
    });
    assert.isTrue(setStub.calledOnce);
    assert.isTrue(setStub.calledWith(101, 'test-project'));
  });

  test('_handleToggleStar called when star is tapped', () => {
    element._change = {
      owner: {_account_id: 1},
      starred: false,
    };
    element._loggedIn = true;
    const stub = sandbox.stub(element, '_handleToggleStar');
    flushAsynchronousOperations();

    MockInteractions.tap(element.$.changeStar.shadowRoot
        .querySelector('button'));
    assert.isTrue(stub.called);
  });

  suite('gr-reporting tests', () => {
    setup(() => {
      element._patchRange = {
        basePatchNum: 'PARENT',
        patchNum: 1,
      };
      sandbox.stub(element, '_getChangeDetail').returns(Promise.resolve());
      sandbox.stub(element, '_getProjectConfig').returns(Promise.resolve());
      sandbox.stub(element, '_reloadComments').returns(Promise.resolve());
      sandbox.stub(element, '_getMergeability').returns(Promise.resolve());
      sandbox.stub(element, '_getLatestCommitMessage')
          .returns(Promise.resolve());
    });

    test('don\'t report changedDisplayed on reply', done => {
      const changeDisplayStub =
        sandbox.stub(element.$.reporting, 'changeDisplayed');
      const changeFullyLoadedStub =
        sandbox.stub(element.$.reporting, 'changeFullyLoaded');
      element._handleReplySent();
      flush(() => {
        assert.isFalse(changeDisplayStub.called);
        assert.isFalse(changeFullyLoadedStub.called);
        done();
      });
    });

    test('report changedDisplayed on _paramsChanged', done => {
      const changeDisplayStub =
        sandbox.stub(element.$.reporting, 'changeDisplayed');
      const changeFullyLoadedStub =
        sandbox.stub(element.$.reporting, 'changeFullyLoaded');
      element._paramsChanged({
        view: GerritNav.View.CHANGE,
        changeNum: 101,
        project: 'test-project',
      });
      flush(() => {
        assert.isTrue(changeDisplayStub.called);
        assert.isTrue(changeFullyLoadedStub.called);
        done();
      });
    });
  });
});
</script>