<!DOCTYPE html>
<!--
Copyright (C) 2016 The Android Open Source Project

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->

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

<script src="../../../bower_components/webcomponentsjs/webcomponents-lite.min.js"></script>
<script src="../../../bower_components/web-component-tester/browser.js"></script>
<link rel="import" href="../../../test/common-test-setup.html"/>
<script src="../../../scripts/util.js"></script>

<link rel="import" href="gr-change-actions.html">

<script>void(0);</script>

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

<script>
  suite('gr-change-actions tests', () => {
    let element;
    let sandbox;

    setup(() => {
      stub('gr-rest-api-interface', {
        getChangeRevisionActions() {
          return Promise.resolve({
            '/': {
              method: 'DELETE',
              label: 'Delete',
              title: 'Delete draft revision 2',
              enabled: true,
            },
            'cherrypick': {
              method: 'POST',
              label: 'Cherry Pick',
              title: 'Cherry pick change to a different branch',
              enabled: true,
            },
            'rebase': {
              method: 'POST',
              label: 'Rebase',
              title: 'Rebase onto tip of branch or parent change',
              enabled: true,
            },
            'submit': {
              method: 'POST',
              label: 'Submit',
              title: 'Submit patch set 2 into master',
              enabled: true,
            },
          });
        },
        send(method, url, payload) {
          if (method !== 'POST') { return Promise.reject('bad method'); }

          if (url === '/changes/test~42/revisions/2/submit') {
            return Promise.resolve({
              ok: true,
              text() { return Promise.resolve(')]}\'\n{}'); },
            });
          } else if (url === '/changes/test~42/revisions/2/rebase') {
            return Promise.resolve({
              ok: true,
              text() { return Promise.resolve(')]}\'\n{}'); },
            });
          }

          return Promise.reject('bad url');
        },
      });

      element = fixture('basic');
      element.change = {};
      element.changeNum = '42';
      element.patchNum = '2';
      element.actions = {
        '/': {
          method: 'DELETE',
          label: 'Delete',
          title: 'Delete draft change 42',
          enabled: true,
        },
      };
      sandbox = sinon.sandbox.create();

      return element.reload();
    });

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

    test('_shouldHideActions', () => {
      assert.isTrue(element._shouldHideActions(undefined, true));
      assert.isTrue(element._shouldHideActions({base: {}}, false));
      assert.isFalse(element._shouldHideActions({base: ['test']}, false));
    });

    test('hide revision action', done => {
      flush(() => {
        const buttonEl = element.$$('[data-action-key="submit"]');
        assert.isOk(buttonEl);
        assert.throws(element.setActionHidden.bind(element, 'invalid type'));
        element.setActionHidden(element.ActionType.REVISION,
            element.RevisionActions.SUBMIT, true);
        assert.lengthOf(element._hiddenActions, 1);
        element.setActionHidden(element.ActionType.REVISION,
            element.RevisionActions.SUBMIT, true);
        assert.lengthOf(element._hiddenActions, 1);
        flush(() => {
          const buttonEl = element.$$('[data-action-key="submit"]');
          assert.isNotOk(buttonEl);

          element.setActionHidden(element.ActionType.REVISION,
              element.RevisionActions.SUBMIT, false);
          flush(() => {
            const buttonEl = element.$$('[data-action-key="submit"]');
            assert.isOk(buttonEl);
            assert.isFalse(buttonEl.hasAttribute('hidden'));
            done();
          });
        });
      });
    });

    test('hide menu action', done => {
      flush(() => {
        const buttonEl =
            element.$.moreActions.$$('span[data-id="delete-revision"]');
        assert.isOk(buttonEl);
        assert.throws(element.setActionHidden.bind(element, 'invalid type'));
        element.setActionHidden(element.ActionType.CHANGE,
            element.ChangeActions.DELETE, true);
        assert.lengthOf(element._hiddenActions, 1);
        element.setActionHidden(element.ActionType.CHANGE,
            element.ChangeActions.DELETE, true);
        assert.lengthOf(element._hiddenActions, 1);
        flush(() => {
          const buttonEl =
              element.$.moreActions.$$('span[data-id="delete-revision"]');
          assert.isNotOk(buttonEl);

          element.setActionHidden(element.ActionType.CHANGE,
              element.RevisionActions.DELETE, false);
          flush(() => {
            const buttonEl =
                element.$.moreActions.$$('span[data-id="delete-revision"]');
            assert.isOk(buttonEl);
            done();
          });
        });
      });
    });

    test('buttons exist', done => {
      element._loading = false;
      flush(() => {
        const buttonEls = Polymer.dom(element.root)
            .querySelectorAll('gr-button');
        const menuItems = element.$.moreActions.items;
        assert.equal(buttonEls.length + menuItems.length, 7);
        assert.isFalse(element.hidden);
        done();
      });
    });

    test('delete buttons have explicit labels', done => {
      flush(() => {
        const deleteItems = element.$.moreActions.items.filter(item => {
          return item.id.startsWith('delete');
        });
        assert.equal(deleteItems.length, 2);
        assert.notEqual(deleteItems[0].name, deleteItems[1].name);
        assert.isTrue(
            deleteItems[0].name === 'Delete Revision' ||
            deleteItems[0].name === 'Delete Change'
        );
        assert.isTrue(
            deleteItems[1].name === 'Delete Revision' ||
            deleteItems[1].name === 'Delete Change'
        );
        done();
      });
    });

    test('get revision object from change', () => {
      const revObj = {_number: 2, foo: 'bar'};
      const change = {
        revisions: {
          rev1: {_number: 1},
          rev2: revObj,
        },
      };
      assert.deepEqual(element._getRevision(change, '2'), revObj);
    });

    test('_actionComparator sort order', () => {
      const actions = [
        {label: '123', __type: 'change', __key: 'review'},
        {label: 'abc-ro', __type: 'revision'},
        {label: 'abc', __type: 'change'},
        {label: 'def', __type: 'change'},
        {label: 'def-p', __type: 'change', __primary: true},
      ];

      const result = actions.slice();
      result.reverse();
      result.sort(element._actionComparator.bind(element));
      assert.deepEqual(result, actions);
    });

    test('submit change', done => {
      sandbox.stub(element.$.restAPI, 'getFromProjectLookup')
          .returns(Promise.resolve('test'));
      sandbox.stub(element, 'fetchIsLatestKnown',
          () => { return Promise.resolve(true); });
      element.change = {
        revisions: {
          rev1: {_number: 1},
          rev2: {_number: 2},
        },
      };
      element.patchNum = '2';

      flush(() => {
        const submitButton = element.$$('gr-button[data-action-key="submit"]');
        assert.ok(submitButton);
        MockInteractions.tap(submitButton);

        // Upon success it should fire the reload-change event.
        element.addEventListener('reload-change', () => {
          done();
        });
      });
    });

    test('submit change with plugin hook', done => {
      sandbox.stub(element, '_canSubmitChange',
          () => { return false; });
      const fireActionStub = sandbox.stub(element, '_fireAction');
      flush(() => {
        const submitButton = element.$$('gr-button[data-action-key="submit"]');
        assert.ok(submitButton);
        MockInteractions.tap(submitButton);
        assert.equal(fireActionStub.callCount, 0);

        done();
      });
    });

    test('chain state', () => {
      assert.equal(element._hasKnownChainState, false);
      element.hasParent = true;
      assert.equal(element._hasKnownChainState, true);
      element.hasParent = false;
    });

    test('_calculateDisabled', () => {
      let hasKnownChainState = false;
      const action = {__key: 'rebase', enabled: true};
      assert.equal(
          element._calculateDisabled(action, hasKnownChainState), true);

      action.__key = 'delete';
      assert.equal(
          element._calculateDisabled(action, hasKnownChainState), false);

      action.__key = 'rebase';
      hasKnownChainState = true;
      assert.equal(
          element._calculateDisabled(action, hasKnownChainState), false);

      action.enabled = false;
      assert.equal(
          element._calculateDisabled(action, hasKnownChainState), true);
    });

    test('rebase change', done => {
      const fireActionStub = sandbox.stub(element, '_fireAction');
      flush(() => {
        const rebaseButton = element.$$('gr-button[data-action-key="rebase"]');
        MockInteractions.tap(rebaseButton);
        const rebaseAction = {
          __key: 'rebase',
          __type: 'revision',
          __primary: false,
          enabled: true,
          label: 'Rebase',
          method: 'POST',
          title: 'Rebase onto tip of branch or parent change',
        };
        // rebase on other
        element.$.confirmRebase.base = '1234';
        element._handleRebaseConfirm();
        assert.deepEqual(fireActionStub.lastCall.args,
          ['/rebase', rebaseAction, true, {base: '1234'}]);

        // rebase on parent
        element.$.confirmRebase.base = null;
        element._handleRebaseConfirm();
        assert.deepEqual(fireActionStub.lastCall.args,
          ['/rebase', rebaseAction, true, {base: null}]);

        // rebase on tip
        element.$.confirmRebase.base = '';
        element._handleRebaseConfirm();
        assert.deepEqual(fireActionStub.lastCall.args,
          ['/rebase', rebaseAction, true, {base: ''}]);

        done();
      });
    });

    test('two dialogs are not shown at the same time', done => {
      element._hasKnownChainState = true;
      flush(() => {
        const rebaseButton = element.$$('gr-button[data-action-key="rebase"]');
        assert.ok(rebaseButton);
        MockInteractions.tap(rebaseButton);
        flushAsynchronousOperations();
        assert.isFalse(element.$.confirmRebase.hidden);

        element._handleCherrypickTap();
        flushAsynchronousOperations();
        assert.isTrue(element.$.confirmRebase.hidden);
        assert.isFalse(element.$.confirmCherrypick.hidden);
        done();
      });
    });

    test('fullscreen-overlay-opened hides content', () => {
      sandbox.spy(element, '_handleHideBackgroundContent');
      element.$.overlay.fire('fullscreen-overlay-opened');
      assert.isTrue(element._handleHideBackgroundContent.called);
      assert.isTrue(element.$.mainContent.classList.contains('overlayOpen'));
    });

    test('fullscreen-overlay-closed shows content', () => {
      sandbox.spy(element, '_handleShowBackgroundContent');
      element.$.overlay.fire('fullscreen-overlay-closed');
      assert.isTrue(element._handleShowBackgroundContent.called);
      assert.isFalse(element.$.mainContent.classList.contains('overlayOpen'));
    });

    suite('cherry-pick', () => {
      let fireActionStub;

      setup(() => {
        fireActionStub = sandbox.stub(element, '_fireAction');
        sandbox.stub(window, 'alert');
      });

      test('works', () => {
        element._handleCherrypickTap();
        const action = {
          __key: 'cherrypick',
          __type: 'revision',
          __primary: false,
          enabled: true,
          label: 'Cherry Pick',
          method: 'POST',
          title: 'Cherry pick change to a different branch',
        };

        element._handleCherrypickConfirm();
        assert.equal(fireActionStub.callCount, 0);

        element.$.confirmCherrypick.branch = 'master';
        element._handleCherrypickConfirm();
        assert.equal(fireActionStub.callCount, 0); // Still needs a message.

        // Add attributes that are used to determine the message.
        element.$.confirmCherrypick.commitMessage = 'foo message';
        element.$.confirmCherrypick.changeStatus = 'OPEN';
        element.$.confirmCherrypick.commitNum = '123';

        element._handleCherrypickConfirm();

        assert.equal(element.$.confirmCherrypick.$.messageInput.value,
            'foo message');

        assert.deepEqual(fireActionStub.lastCall.args, [
          '/cherrypick', action, true, {
            destination: 'master',
            message: 'foo message',
          },
        ]);
      });

      test('branch name cleared when re-open cherrypick', () => {
        const emptyBranchName = '';
        element.$.confirmCherrypick.branch = 'master';

        element._handleCherrypickTap();
        assert.equal(element.$.confirmCherrypick.branch, emptyBranchName);
      });
    });

    suite('move change', () => {
      let fireActionStub;

      setup(() => {
        fireActionStub = sandbox.stub(element, '_fireAction');
        sandbox.stub(window, 'alert');
      });

      test('works', () => {
        element._handleMoveTap();

        element._handleMoveConfirm();
        assert.equal(fireActionStub.callCount, 0);

        element.$.confirmMove.branch = 'master';
        element._handleMoveConfirm();
        assert.equal(fireActionStub.callCount, 1);
      });

      test('branch name cleared when re-open move', () => {
        const emptyBranchName = '';
        element.$.confirmMove.branch = 'master';

        element._handleMoveTap();
        assert.equal(element.$.confirmMove.branch, emptyBranchName);
      });
    });

    test('custom actions', done => {
      // Add a button with the same key as a server-based one to ensure
      // collisions are taken care of.
      const key = element.addActionButton(element.ActionType.REVISION, 'Bork!');
      element.addEventListener(key + '-tap', e => {
        assert.equal(e.detail.node.getAttribute('data-action-key'), key);
        element.removeActionButton(key);
        flush(() => {
          assert.notOk(element.$$('[data-action-key="' + key + '"]'));
          done();
        });
      });
      flush(() => {
        MockInteractions.tap(element.$$('[data-action-key="' + key + '"]'));
      });
    });

    test('_setLoadingOnButtonWithKey top-level', () => {
      const key = 'rebase';
      const type = 'revision';
      const cleanup = element._setLoadingOnButtonWithKey(type, key);
      assert.equal(element._actionLoadingMessage, 'Rebasing...');

      const button = element.$$('[data-action-key="' + key + '"]');
      assert.isTrue(button.hasAttribute('loading'));
      assert.isTrue(button.disabled);

      assert.isOk(cleanup);
      assert.isFunction(cleanup);
      cleanup();

      assert.isFalse(button.hasAttribute('loading'));
      assert.isFalse(button.disabled);
      assert.isNotOk(element._actionLoadingMessage);
    });

    test('_setLoadingOnButtonWithKey overflow menu', () => {
      const key = 'cherrypick';
      const type = 'revision';
      const cleanup = element._setLoadingOnButtonWithKey(type, key);
      assert.equal(element._actionLoadingMessage, 'Cherry-Picking...');
      assert.include(element._disabledMenuActions, 'cherrypick');
      assert.isFunction(cleanup);

      cleanup();

      assert.notOk(element._actionLoadingMessage);
      assert.notInclude(element._disabledMenuActions, 'cherrypick');
    });

    suite('revert change', () => {
      let alertStub;
      let fireActionStub;

      setup(() => {
        fireActionStub = sandbox.stub(element, '_fireAction');
        alertStub = sandbox.stub(window, 'alert');
        element.actions = {
          revert: {
            method: 'POST',
            label: 'Revert',
            title: 'Revert the change',
            enabled: true,
          },
        };
        return element.reload();
      });

      test('revert change with plugin hook', done => {
        element.change = {
          current_revision: 'abc1234',
        };
        const newRevertMsg = 'Modified revert msg';
        sandbox.stub(element, '_modifyRevertMsg',
            () => { return newRevertMsg; });
        sandbox.stub(element.$.confirmRevertDialog, 'populateRevertMessage',
            () => { return 'original msg'; });
        flush(() => {
          const revertButton =
              element.$$('gr-button[data-action-key="revert"]');
          MockInteractions.tap(revertButton);

          assert.equal(element.$.confirmRevertDialog.message, newRevertMsg);
          done();
        });
      });

      test('works', () => {
        element.change = {
          current_revision: 'abc1234',
        };
        sandbox.stub(element.$.confirmRevertDialog, 'populateRevertMessage',
            () => { return 'original msg'; });
        const revertButton = element.$$('gr-button[data-action-key="revert"]');
        MockInteractions.tap(revertButton);

        element.$.confirmRevertDialog.message = 'foo message';
        element._handleRevertDialogConfirm();
        assert.notOk(alertStub.called);

        const action = {
          __key: 'revert',
          __type: 'change',
          __primary: false,
          enabled: true,
          label: 'Revert',
          method: 'POST',
          title: 'Revert the change',
        };
        assert.deepEqual(fireActionStub.lastCall.args, [
          '/revert', action, false, {
            message: 'foo message',
          }]);
      });
    });

    suite('mark change private', () => {
      setup(() => {
        const privateAction = {
          __key: 'private',
          __type: 'change',
          __primary: false,
          method: 'POST',
          label: 'Mark private',
          title: 'Working...',
          enabled: true,
        };

        element.actions = {
          private: privateAction,
        };

        element.change.is_private = false;

        element.changeNum = '2';
        element.patchNum = '2';

        return element.reload();
      });

      test('make sure the mark private change button is not outside of the ' +
           'overflow menu', done => {
        flush(() => {
          assert.isNotOk(element.$$('[data-action-key="private"]'));
          done();
        });
      });

      test('private change', done => {
        flush(() => {
          assert.isOk(
              element.$.moreActions.$$('span[data-id="private-change"]'));
          element.setActionOverflow('change', 'private', false);
          flushAsynchronousOperations();
          assert.isOk(element.$$('[data-action-key="private"]'));
          assert.isNotOk(
              element.$.moreActions.$$('span[data-id="private-change"]'));
          done();
        });
      });
    });

    suite('unmark private change', () => {
      setup(() => {
        const unmarkPrivateAction = {
          __key: 'private.delete',
          __type: 'change',
          __primary: false,
          method: 'POST',
          label: 'Unmark private',
          title: 'Working...',
          enabled: true,
        };

        element.actions = {
          'private.delete': unmarkPrivateAction,
        };

        element.change.is_private = true;

        element.changeNum = '2';
        element.patchNum = '2';

        return element.reload();
      });

      test('make sure the unmark private change button is not outside of the ' +
           'overflow menu', done => {
        flush(() => {
          assert.isNotOk(element.$$('[data-action-key="private.delete"]'));
          done();
        });
      });

      test('unmark the private change', done => {
        flush(() => {
          assert.isOk(
              element.$.moreActions.$$('span[data-id="private.delete-change"]')
          );
          element.setActionOverflow('change', 'private.delete', false);
          flushAsynchronousOperations();
          assert.isOk(element.$$('[data-action-key="private.delete"]'));
          assert.isNotOk(
              element.$.moreActions.$$('span[data-id="private.delete-change"]')
          );
          done();
        });
      });
    });

    suite('delete change', () => {
      let fireActionStub;
      let deleteAction;

      setup(() => {
        fireActionStub = sandbox.stub(element, '_fireAction');
        element.change = {
          current_revision: 'abc1234',
        };
        deleteAction = {
          method: 'DELETE',
          label: 'Delete Change',
          title: 'Delete change X_X',
          enabled: true,
        };
        element.actions = {
          '/': deleteAction,
        };
      });

      test('does not delete on action', () => {
        element._handleDeleteTap();
        assert.isFalse(fireActionStub.called);
      });

      test('shows confirm dialog', () => {
        element._handleDeleteTap();
        assert.isFalse(element.$$('#confirmDeleteDialog').hidden);
        MockInteractions.tap(
            element.$$('#confirmDeleteDialog').$$('gr-button[primary]'));
        flushAsynchronousOperations();
        assert.isTrue(fireActionStub.calledWith('/', deleteAction, false));
      });

      test('hides delete confirm on cancel', () => {
        element._handleDeleteTap();
        MockInteractions.tap(
            element.$$('#confirmDeleteDialog').$$('gr-button:not([primary])'));
        flushAsynchronousOperations();
        assert.isTrue(element.$$('#confirmDeleteDialog').hidden);
        assert.isFalse(fireActionStub.called);
      });
    });

    suite('ignore change', () => {
      setup(done => {
        sandbox.stub(element, '_fireAction');

        const IgnoreAction = {
          __key: 'ignore',
          __type: 'change',
          __primary: false,
          method: 'PUT',
          label: 'Ignore',
          title: 'Working...',
          enabled: true,
        };

        element.actions = {
          ignore: IgnoreAction,
        };

        element.changeNum = '2';
        element.patchNum = '2';

        element.reload().then(() => { flush(done); });
      });

      test('make sure the ignore button is not outside of the overflow menu',
          () => {
            assert.isNotOk(element.$$('[data-action-key="ignore"]'));
          });

      test('ignoring change', () => {
        assert.isOk(element.$.moreActions.$$('span[data-id="ignore-change"]'));
        element.setActionOverflow('change', 'ignore', false);
        flushAsynchronousOperations();
        assert.isOk(element.$$('[data-action-key="ignore"]'));
        assert.isNotOk(
            element.$.moreActions.$$('span[data-id="ignore-change"]'));
      });
    });

    suite('unignore change', () => {
      setup(done => {
        sandbox.stub(element, '_fireAction');

        const UnignoreAction = {
          __key: 'unignore',
          __type: 'change',
          __primary: false,
          method: 'PUT',
          label: 'Unignore',
          title: 'Working...',
          enabled: true,
        };

        element.actions = {
          unignore: UnignoreAction,
        };

        element.changeNum = '2';
        element.patchNum = '2';

        element.reload().then(() => { flush(done); });
      });


      test('unignore button is not outside of the overflow menu', () => {
        assert.isNotOk(element.$$('[data-action-key="unignore"]'));
      });

      test('unignoring change', () => {
        assert.isOk(
            element.$.moreActions.$$('span[data-id="unignore-change"]'));
        element.setActionOverflow('change', 'unignore', false);
        flushAsynchronousOperations();
        assert.isOk(element.$$('[data-action-key="unignore"]'));
        assert.isNotOk(
            element.$.moreActions.$$('span[data-id="unignore-change"]'));
      });
    });

    suite('mute change', () => {
      setup(done => {
        sandbox.stub(element, '_fireAction');

        const MuteAction = {
          __key: 'mute',
          __type: 'change',
          __primary: false,
          method: 'PUT',
          label: 'Mute',
          title: 'Working...',
          enabled: true,
        };

        element.actions = {
          mute: MuteAction,
        };

        element.changeNum = '2';
        element.patchNum = '2';

        element.reload().then(() => { flush(done); });
      });

      test('make sure the mute button is not outside of the overflow menu',
          () => {
            assert.isNotOk(element.$$('[data-action-key="mute"]'));
          });

      test('muting change', () => {
        assert.isOk(element.$.moreActions.$$('span[data-id="mute-change"]'));
        element.setActionOverflow('change', 'mute', false);
        flushAsynchronousOperations();
        assert.isOk(element.$$('[data-action-key="mute"]'));
        assert.isNotOk(
            element.$.moreActions.$$('span[data-id="mute-change"]'));
      });
    });

    suite('unmute change', () => {
      setup(done => {
        sandbox.stub(element, '_fireAction');

        const UnmuteAction = {
          __key: 'unmute',
          __type: 'change',
          __primary: false,
          method: 'PUT',
          label: 'Unmute',
          title: 'Working...',
          enabled: true,
        };

        element.actions = {
          unmute: UnmuteAction,
        };

        element.changeNum = '2';
        element.patchNum = '2';

        element.reload().then(() => { flush(done); });
      });


      test('unmute button not outside of the overflow menu', () => {
        assert.isNotOk(element.$$('[data-action-key="unmute"]'));
      });

      test('unmuting change', () => {
        assert.isOk(
            element.$.moreActions.$$('span[data-id="unmute-change"]'));
        element.setActionOverflow('change', 'unmute', false);
        flushAsynchronousOperations();
        assert.isOk(element.$$('[data-action-key="unmute"]'));
        assert.isNotOk(
            element.$.moreActions.$$('span[data-id="unmute-change"]'));
      });
    });

    suite('quick approve', () => {
      setup(() => {
        element.change = {
          current_revision: 'abc1234',
        };
        element.change = {
          current_revision: 'abc1234',
          labels: {
            foo: {
              values: {
                '-1': '',
                ' 0': '',
                '+1': '',
              },
            },
          },
          permitted_labels: {
            foo: ['-1', ' 0', '+1'],
          },
        };
        flushAsynchronousOperations();
      });

      test('added when can approve', () => {
        const approveButton =
            element.$$('gr-button[data-action-key=\'review\']');
        assert.isNotNull(approveButton);
      });

      test('is first in list of actions', () => {
        const approveButton = element.$$('gr-button');
        assert.equal(approveButton.getAttribute('data-label'), 'foo+1');
      });

      test('not added when already approved', () => {
        element.change = {
          current_revision: 'abc1234',
          labels: {
            foo: {
              approved: {},
              values: {},
            },
          },
          permitted_labels: {
            foo: [' 0', '+1'],
          },
        };
        flushAsynchronousOperations();
        const approveButton =
            element.$$('gr-button[data-action-key=\'review\']');
        assert.isNull(approveButton);
      });

      test('not added when label not permitted', () => {
        element.change = {
          current_revision: 'abc1234',
          labels: {
            foo: {values: {}},
          },
          permitted_labels: {
            bar: [],
          },
        };
        flushAsynchronousOperations();
        const approveButton =
            element.$$('gr-button[data-action-key=\'review\']');
        assert.isNull(approveButton);
      });

      test('approves when tapped', () => {
        const fireActionStub = sandbox.stub(element, '_fireAction');
        MockInteractions.tap(
            element.$$('gr-button[data-action-key=\'review\']'));
        flushAsynchronousOperations();
        assert.isTrue(fireActionStub.called);
        assert.isTrue(fireActionStub.calledWith('/review'));
        const payload = fireActionStub.lastCall.args[3];
        assert.deepEqual(payload.labels, {foo: '+1'});
      });

      test('not added when multiple labels are required', () => {
        element.change = {
          current_revision: 'abc1234',
          labels: {
            foo: {values: {}},
            bar: {values: {}},
          },
          permitted_labels: {
            foo: [' 0', '+1'],
            bar: [' 0', '+1', '+2'],
          },
        };
        flushAsynchronousOperations();
        const approveButton =
            element.$$('gr-button[data-action-key=\'review\']');
        assert.isNull(approveButton);
      });

      test('button label for missing approval', () => {
        element.change = {
          current_revision: 'abc1234',
          labels: {
            foo: {
              values: {
                ' 0': '',
                '+1': '',
              },
            },
            bar: {approved: {}, values: {}},
          },
          permitted_labels: {
            foo: [' 0', '+1'],
            bar: [' 0', '+1', '+2'],
          },
        };
        flushAsynchronousOperations();
        const approveButton =
            element.$$('gr-button[data-action-key=\'review\']');
        assert.equal(approveButton.getAttribute('data-label'), 'foo+1');
      });

      test('no quick approve if score is not maximal for a label', () => {
        element.change = {
          current_revision: 'abc1234',
          labels: {
            bar: {
              value: 1,
              values: {
                ' 0': '',
                '+1': '',
                '+2': '',
              },
            },
          },
          permitted_labels: {
            bar: [' 0', '+1'],
          },
        };
        flushAsynchronousOperations();
        const approveButton =
            element.$$('gr-button[data-action-key=\'review\']');
        assert.isNull(approveButton);
      });

      test('approving label with a non-max score', () => {
        element.change = {
          current_revision: 'abc1234',
          labels: {
            bar: {
              value: 1,
              values: {
                ' 0': '',
                '+1': '',
                '+2': '',
              },
            },
          },
          permitted_labels: {
            bar: [' 0', '+1', '+2'],
          },
        };
        flushAsynchronousOperations();
        const approveButton =
            element.$$('gr-button[data-action-key=\'review\']');
        assert.equal(approveButton.getAttribute('data-label'), 'bar+2');
      });
    });

    test('adds download revision action', () => {
      const handler = sandbox.stub();
      element.addEventListener('download-tap', handler);
      assert.ok(element.revisionActions.download);
      element._handleDownloadTap();
      flushAsynchronousOperations();

      assert.isTrue(handler.called);
    });

    suite('setActionOverflow', () => {
      test('move action from overflow', () => {
        assert.isNotOk(element.$$('[data-action-key="cherrypick"]'));
        assert.strictEqual(
            element.$.moreActions.items[0].id, 'cherrypick-revision');
        element.setActionOverflow('revision', 'cherrypick', false);
        flushAsynchronousOperations();
        assert.isOk(element.$$('[data-action-key="cherrypick"]'));
        assert.notEqual(
            element.$.moreActions.items[0].id, 'cherrypick-revision');
      });

      test('move action to overflow', () => {
        assert.isOk(element.$$('[data-action-key="submit"]'));
        element.setActionOverflow('revision', 'submit', true);
        flushAsynchronousOperations();
        assert.isNotOk(element.$$('[data-action-key="submit"]'));
        assert.strictEqual(
            element.$.moreActions.items[4].id, 'submit-revision');
      });

      suite('_waitForChangeReachable', () => {
        setup(() => {
          sandbox.stub(element, 'async', fn => fn());
        });

        const makeGetChange = numTries => {
          return () => {
            if (numTries === 1) {
              return Promise.resolve({_number: 123});
            } else {
              numTries--;
              return Promise.resolve(undefined);
            }
          };
        };

        test('succeed', () => {
          sandbox.stub(element.$.restAPI, 'getChange', makeGetChange(5));
          return element._waitForChangeReachable(123).then(success => {
            assert.isTrue(success);
          });
        });

        test('fail', () => {
          sandbox.stub(element.$.restAPI, 'getChange', makeGetChange(6));
          return element._waitForChangeReachable(123).then(success => {
            assert.isFalse(success);
          });
        });
      });
    });

    suite('_send', () => {
      let cleanup;
      let payload;
      let onShowAlert;

      setup(() => {
        cleanup = sinon.stub();
        element.changeNum = 42;
        element.patchNum = 12;
        payload = {foo: 'bar'};

        onShowAlert = sinon.stub();
        element.addEventListener('show-alert', onShowAlert);
      });

      suite('happy path', () => {
        let sendStub;

        setup(() => {
          sandbox.stub(element, 'fetchIsLatestKnown')
              .returns(Promise.resolve(true));
          sendStub = sandbox.stub(element.$.restAPI, 'getChangeURLAndSend')
              .returns(Promise.resolve({}));
        });

        test('change action', () => {
          return element._send('DELETE', payload, '/endpoint', false, cleanup)
              .then(() => {
                assert.isFalse(onShowAlert.called);
                assert.isTrue(cleanup.calledOnce);
                assert.isTrue(sendStub.calledWith(42, 'DELETE', null,
                    '/endpoint', payload));
              });
        });

        test('revision action', () => {
          return element._send('DELETE', payload, '/endpoint', true, cleanup)
              .then(() => {
                assert.isFalse(onShowAlert.called);
                assert.isTrue(cleanup.calledOnce);
                assert.isTrue(sendStub.calledWith(42, 'DELETE', 12, '/endpoint',
                    payload));
              });
        });
      });

      suite('failure modes', () => {
        test('non-latest', () => {
          sandbox.stub(element, 'fetchIsLatestKnown')
              .returns(Promise.resolve(false));
          const sendStub = sandbox.stub(element.$.restAPI,
              'getChangeURLAndSend');

          return element._send('DELETE', payload, '/endpoint', true, cleanup)
              .then(() => {
                assert.isTrue(onShowAlert.calledOnce);
                assert.isTrue(cleanup.calledOnce);
                assert.isFalse(sendStub.called);
              });
        });

        test('send fails', () => {
          sandbox.stub(element, 'fetchIsLatestKnown')
              .returns(Promise.resolve(true));
          const sendStub = sandbox.stub(element.$.restAPI,
              'getChangeURLAndSend',
              (num, method, patchNum, endpoint, payload, onErr) => {
                onErr();
                return Promise.resolve(null);
              });
          const handleErrorStub = sandbox.stub(element, '_handleResponseError');

          return element._send('DELETE', payload, '/endpoint', true, cleanup)
              .then(() => {
                assert.isFalse(onShowAlert.called);
                assert.isTrue(cleanup.called);
                assert.isTrue(sendStub.calledOnce);
                assert.isTrue(handleErrorStub.called);
              });
        });
      });
    });
  });
</script>