/**
 * @license
 * Copyright (C) 2020 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import '../../../test/common-test-setup-karma.js';
import '../../core/gr-router/gr-router.js';
import './gr-change-metadata.js';
import {GerritNav} from '../../core/gr-navigation/gr-navigation.js';
import {pluginLoader} from '../../shared/gr-js-api-interface/gr-plugin-loader.js';
import {pluginEndpoints} from '../../shared/gr-js-api-interface/gr-plugin-endpoints.js';
import {_testOnly_initGerritPluginApi} from '../../shared/gr-js-api-interface/gr-gerrit.js';

const basicFixture = fixtureFromElement('gr-change-metadata');

const pluginApi = _testOnly_initGerritPluginApi();

suite('gr-change-metadata tests', () => {
  let element;

  setup(() => {
    stub('gr-rest-api-interface', {
      getConfig() { return Promise.resolve({}); },
      getLoggedIn() { return Promise.resolve(false); },
    });

    element = basicFixture.instantiate();
    sinon.stub(pluginEndpoints, 'importUrl')
        .callsFake( url => Promise.resolve());
  });

  test('computed fields', () => {
    assert.isFalse(element._computeHideStrategy({status: 'NEW'}));
    assert.isTrue(element._computeHideStrategy({status: 'MERGED'}));
    assert.isTrue(element._computeHideStrategy({status: 'ABANDONED'}));
    assert.equal(element._computeStrategy({submit_type: 'CHERRY_PICK'}),
        'Cherry Pick');
    assert.equal(element._computeStrategy({submit_type: 'REBASE_ALWAYS'}),
        'Rebase Always');
  });

  test('computed fields requirements', () => {
    assert.isFalse(element._computeShowRequirements({status: 'MERGED'}));
    assert.isFalse(element._computeShowRequirements({status: 'ABANDONED'}));

    // No labels and no requirements: submit status is useless
    assert.isFalse(element._computeShowRequirements({
      status: 'NEW',
      labels: {},
    }));

    // Work in Progress: submit status should be present
    assert.isTrue(element._computeShowRequirements({
      status: 'NEW',
      labels: {},
      work_in_progress: true,
    }));

    // We have at least one reason to display Submit Status
    assert.isTrue(element._computeShowRequirements({
      status: 'NEW',
      labels: {
        Verified: {
          approved: false,
        },
      },
      requirements: [],
    }));
    assert.isTrue(element._computeShowRequirements({
      status: 'NEW',
      labels: {},
      requirements: [{
        fallback_text: 'Resolve all comments',
        status: 'OK',
      }],
    }));
  });

  test('show strategy for open change', () => {
    element.change = {status: 'NEW', submit_type: 'CHERRY_PICK', labels: {}};
    flushAsynchronousOperations();
    const strategy = element.shadowRoot
        .querySelector('.strategy');
    assert.ok(strategy);
    assert.isFalse(strategy.hasAttribute('hidden'));
    assert.equal(strategy.children[1].innerHTML, 'Cherry Pick');
  });

  test('hide strategy for closed change', () => {
    element.change = {status: 'MERGED', labels: {}};
    flushAsynchronousOperations();
    assert.isTrue(element.shadowRoot
        .querySelector('.strategy').hasAttribute('hidden'));
  });

  test('weblinks use GerritNav interface', () => {
    const weblinksStub = sinon.stub(GerritNav, '_generateWeblinks')
        .returns([{name: 'stubb', url: '#s'}]);
    element.commitInfo = {};
    element.serverConfig = {};
    flushAsynchronousOperations();
    const webLinks = element.$.webLinks;
    assert.isTrue(weblinksStub.called);
    assert.isFalse(webLinks.hasAttribute('hidden'));
    assert.equal(element._computeWebLinks(element.commitInfo).length, 1);
  });

  test('weblinks hidden when no weblinks', () => {
    element.commitInfo = {};
    element.serverConfig = {};
    flushAsynchronousOperations();
    const webLinks = element.$.webLinks;
    assert.isTrue(webLinks.hasAttribute('hidden'));
  });

  test('weblinks hidden when only gitiles weblink', () => {
    element.commitInfo = {web_links: [{name: 'gitiles', url: '#'}]};
    element.serverConfig = {};
    flushAsynchronousOperations();
    const webLinks = element.$.webLinks;
    assert.isTrue(webLinks.hasAttribute('hidden'));
    assert.equal(element._computeWebLinks(element.commitInfo), null);
  });

  test('weblinks hidden when sole weblink is set as primary', () => {
    const browser = 'browser';
    element.commitInfo = {web_links: [{name: browser, url: '#'}]};
    element.serverConfig = {
      gerrit: {
        primary_weblink_name: browser,
      },
    };
    flushAsynchronousOperations();
    const webLinks = element.$.webLinks;
    assert.isTrue(webLinks.hasAttribute('hidden'));
  });

  test('weblinks are visible when other weblinks', () => {
    const router = document.createElement('gr-router');
    sinon.stub(GerritNav, '_generateWeblinks').callsFake(
        router._generateWeblinks.bind(router));

    element.commitInfo = {web_links: [{name: 'test', url: '#'}]};
    flushAsynchronousOperations();
    const webLinks = element.$.webLinks;
    assert.isFalse(webLinks.hasAttribute('hidden'));
    assert.equal(element._computeWebLinks(element.commitInfo).length, 1);
    // With two non-gitiles weblinks, there are two returned.
    element.commitInfo = {
      web_links: [{name: 'test', url: '#'}, {name: 'test2', url: '#'}]};
    assert.equal(element._computeWebLinks(element.commitInfo).length, 2);
  });

  test('weblinks are visible when gitiles and other weblinks', () => {
    const router = document.createElement('gr-router');
    sinon.stub(GerritNav, '_generateWeblinks').callsFake(
        router._generateWeblinks.bind(router));

    element.commitInfo = {
      web_links: [{name: 'test', url: '#'}, {name: 'gitiles', url: '#'}]};
    flushAsynchronousOperations();
    const webLinks = element.$.webLinks;
    assert.isFalse(webLinks.hasAttribute('hidden'));
    // Only the non-gitiles weblink is returned.
    assert.equal(element._computeWebLinks(element.commitInfo).length, 1);
  });

  suite('_getNonOwnerRole', () => {
    let change;

    setup(() => {
      change = {
        owner: {
          email: 'abc@def',
          _account_id: 1019328,
        },
        revisions: {
          rev1: {
            _number: 1,
            uploader: {
              email: 'ghi@def',
              _account_id: 1011123,
            },
            commit: {
              author: {email: 'jkl@def'},
              committer: {email: 'ghi@def'},
            },
          },
        },
        current_revision: 'rev1',
      };
    });

    suite('role=uploader', () => {
      test('_getNonOwnerRole for uploader', () => {
        assert.deepEqual(
            element._getNonOwnerRole(change, element._CHANGE_ROLE.UPLOADER),
            {email: 'ghi@def', _account_id: 1011123});
      });

      test('_getNonOwnerRole that it does not return uploader', () => {
        // Set the uploader email to be the same as the owner.
        change.revisions.rev1.uploader._account_id = 1019328;
        assert.isNull(element._getNonOwnerRole(change,
            element._CHANGE_ROLE.UPLOADER));
      });

      test('_getNonOwnerRole null for uploader with no current rev', () => {
        delete change.current_revision;
        assert.isNull(element._getNonOwnerRole(change,
            element._CHANGE_ROLE.UPLOADER));
      });

      test('_computeShowRoleClass show uploader', () => {
        assert.equal(element._computeShowRoleClass(
            change, element._CHANGE_ROLE.UPLOADER), '');
      });

      test('_computeShowRoleClass hide uploader', () => {
        // Set the uploader email to be the same as the owner.
        change.revisions.rev1.uploader._account_id = 1019328;
        assert.equal(element._computeShowRoleClass(change,
            element._CHANGE_ROLE.UPLOADER), 'hideDisplay');
      });
    });

    suite('role=committer', () => {
      test('_getNonOwnerRole for committer', () => {
        assert.deepEqual(
            element._getNonOwnerRole(change, element._CHANGE_ROLE.COMMITTER),
            {email: 'ghi@def'});
      });

      test('_getNonOwnerRole that it does not return committer', () => {
        // Set the committer email to be the same as the owner.
        change.revisions.rev1.commit.committer.email = 'abc@def';
        assert.isNull(element._getNonOwnerRole(change,
            element._CHANGE_ROLE.COMMITTER));
      });

      test('_getNonOwnerRole null for committer with no current rev', () => {
        delete change.current_revision;
        assert.isNull(element._getNonOwnerRole(change,
            element._CHANGE_ROLE.COMMITTER));
      });

      test('_getNonOwnerRole null for committer with no commit', () => {
        delete change.revisions.rev1.commit;
        assert.isNull(element._getNonOwnerRole(change,
            element._CHANGE_ROLE.COMMITTER));
      });

      test('_getNonOwnerRole null for committer with no committer', () => {
        delete change.revisions.rev1.commit.committer;
        assert.isNull(element._getNonOwnerRole(change,
            element._CHANGE_ROLE.COMMITTER));
      });
    });

    suite('role=author', () => {
      test('_getNonOwnerRole for author', () => {
        assert.deepEqual(
            element._getNonOwnerRole(change, element._CHANGE_ROLE.AUTHOR),
            {email: 'jkl@def'});
      });

      test('_getNonOwnerRole that it does not return author', () => {
        // Set the author email to be the same as the owner.
        change.revisions.rev1.commit.author.email = 'abc@def';
        assert.isNull(element._getNonOwnerRole(change,
            element._CHANGE_ROLE.AUTHOR));
      });

      test('_getNonOwnerRole null for author with no current rev', () => {
        delete change.current_revision;
        assert.isNull(element._getNonOwnerRole(change,
            element._CHANGE_ROLE.AUTHOR));
      });

      test('_getNonOwnerRole null for author with no commit', () => {
        delete change.revisions.rev1.commit;
        assert.isNull(element._getNonOwnerRole(change,
            element._CHANGE_ROLE.AUTHOR));
      });

      test('_getNonOwnerRole null for author with no author', () => {
        delete change.revisions.rev1.commit.author;
        assert.isNull(element._getNonOwnerRole(change,
            element._CHANGE_ROLE.AUTHOR));
      });
    });
  });

  test('Push Certificate Validation test BAD', () => {
    const serverConfig = {
      receive: {
        enable_signed_push: true,
      },
    };
    const change = {
      change_id: 'Iad9dc96274af6946f3632be53b106ef80f7ba6ca',
      owner: {
        _account_id: 1019328,
      },
      revisions: {
        rev1: {
          _number: 1,
          push_certificate: {
            key: {
              status: 'BAD',
              problems: [
                'No public keys found for key ID E5E20E52',
              ],
            },
          },
        },
      },
      current_revision: 'rev1',
      status: 'NEW',
      labels: {},
      mergeable: true,
    };
    const result =
        element._computePushCertificateValidation(serverConfig, change);
    assert.equal(result.message,
        'Push certificate is invalid:\n' +
        'No public keys found for key ID E5E20E52');
    assert.equal(result.icon, 'gr-icons:close');
    assert.equal(result.class, 'invalid');
  });

  test('Push Certificate Validation test TRUSTED', () => {
    const serverConfig = {
      receive: {
        enable_signed_push: true,
      },
    };
    const change = {
      change_id: 'Iad9dc96274af6946f3632be53b106ef80f7ba6ca',
      owner: {
        _account_id: 1019328,
      },
      revisions: {
        rev1: {
          _number: 1,
          push_certificate: {
            key: {
              status: 'TRUSTED',
            },
          },
        },
      },
      current_revision: 'rev1',
      status: 'NEW',
      labels: {},
      mergeable: true,
    };
    const result =
        element._computePushCertificateValidation(serverConfig, change);
    assert.equal(result.message,
        'Push certificate is valid and key is trusted');
    assert.equal(result.icon, 'gr-icons:check');
    assert.equal(result.class, 'trusted');
  });

  test('Push Certificate Validation is missing test', () => {
    const serverConfig = {
      receive: {
        enable_signed_push: true,
      },
    };
    const change = {
      change_id: 'Iad9dc96274af6946f3632be53b106ef80f7ba6ca',
      owner: {
        _account_id: 1019328,
      },
      revisions: {
        rev1: {
          _number: 1,
        },
      },
      current_revision: 'rev1',
      status: 'NEW',
      labels: {},
      mergeable: true,
    };
    const result =
        element._computePushCertificateValidation(serverConfig, change);
    assert.equal(result.message,
        'This patch set was created without a push certificate');
    assert.equal(result.icon, 'gr-icons:help');
    assert.equal(result.class, 'help');
  });

  test('_computeParents', () => {
    const parents = [{commit: '123', subject: 'abc'}];
    const revision = {commit: {parents}};
    assert.deepEqual(element._computeParents({}, {}), []);
    assert.equal(element._computeParents(null, revision), parents);
    const change = current_revision => {
      return {current_revision, revisions: {456: revision}};
    };
    assert.deepEqual(element._computeParents(change(null), null), []);
    const change_bad_revision = change('789');
    assert.deepEqual(element._computeParents(change_bad_revision, {}), []);
    const change_no_commit = {current_revision: '456', revisions: {456: {}}};
    assert.deepEqual(element._computeParents(change_no_commit, null), []);
    const change_good = change('456');
    assert.equal(element._computeParents(change_good, null), parents);
  });

  test('_currentParents', () => {
    const revision = parent => {
      return {commit: {parents: [{commit: parent, subject: 'abc'}]}};
    };
    element.change = {
      current_revision: '456',
      revisions: {456: revision('111')},
    };
    element.revision = revision('222');
    assert.equal(element._currentParents[0].commit, '222');
    element.revision = revision('333');
    assert.equal(element._currentParents[0].commit, '333');
    element.revision = null;
    assert.equal(element._currentParents[0].commit, '111');
    element.change = {current_revision: null};
    assert.deepEqual(element._currentParents, []);
  });

  test('_computeParentsLabel', () => {
    const parent = {commit: 'abc123', subject: 'My parent commit'};
    assert.equal(element._computeParentsLabel([parent]), 'Parent');
    assert.equal(element._computeParentsLabel([parent, parent]),
        'Parents');
  });

  test('_computeParentListClass', () => {
    const parent = {commit: 'abc123', subject: 'My parent commit'};
    assert.equal(element._computeParentListClass([parent], true),
        'parentList nonMerge current');
    assert.equal(element._computeParentListClass([parent], false),
        'parentList nonMerge notCurrent');
    assert.equal(element._computeParentListClass([parent, parent], false),
        'parentList merge notCurrent');
    assert.equal(element._computeParentListClass([parent, parent], true),
        'parentList merge current');
  });

  test('_showAddTopic', () => {
    assert.isTrue(element._showAddTopic(null, false));
    assert.isTrue(element._showAddTopic({base: {topic: null}}, false));
    assert.isFalse(element._showAddTopic({base: {topic: null}}, true));
    assert.isFalse(element._showAddTopic({base: {topic: 'foo'}}, true));
    assert.isFalse(element._showAddTopic({base: {topic: 'foo'}}, false));
  });

  test('_showTopicChip', () => {
    assert.isFalse(element._showTopicChip(null, false));
    assert.isFalse(element._showTopicChip({base: {topic: null}}, false));
    assert.isFalse(element._showTopicChip({base: {topic: null}}, true));
    assert.isFalse(element._showTopicChip({base: {topic: 'foo'}}, true));
    assert.isTrue(element._showTopicChip({base: {topic: 'foo'}}, false));
  });

  test('_showCherryPickOf', () => {
    assert.isFalse(element._showCherryPickOf(null));
    assert.isFalse(element._showCherryPickOf({
      base: {
        cherry_pick_of_change: null,
        cherry_pick_of_patch_set: null,
      },
    }));
    assert.isTrue(element._showCherryPickOf({
      base: {
        cherry_pick_of_change: 123,
        cherry_pick_of_patch_set: 1,
      },
    }));
  });

  suite('Topic removal', () => {
    let change;
    setup(() => {
      change = {
        _number: 'the number',
        actions: {
          topic: {enabled: false},
        },
        change_id: 'the id',
        topic: 'the topic',
        status: 'NEW',
        submit_type: 'CHERRY_PICK',
        labels: {
          test: {
            all: [{_account_id: 1, name: 'bojack', value: 1}],
            default_value: 0,
            values: [],
          },
        },
        removable_reviewers: [],
      };
    });

    test('_computeTopicReadOnly', () => {
      let mutable = false;
      assert.isTrue(element._computeTopicReadOnly(mutable, change));
      mutable = true;
      assert.isTrue(element._computeTopicReadOnly(mutable, change));
      change.actions.topic.enabled = true;
      assert.isFalse(element._computeTopicReadOnly(mutable, change));
      mutable = false;
      assert.isTrue(element._computeTopicReadOnly(mutable, change));
    });

    test('topic read only hides delete button', () => {
      element.account = {};
      element.change = change;
      flushAsynchronousOperations();
      const button = element.shadowRoot
          .querySelector('gr-linked-chip').shadowRoot
          .querySelector('gr-button');
      assert.isTrue(button.hasAttribute('hidden'));
    });

    test('topic not read only does not hide delete button', () => {
      element.account = {test: true};
      change.actions.topic.enabled = true;
      element.change = change;
      flushAsynchronousOperations();
      const button = element.shadowRoot
          .querySelector('gr-linked-chip').shadowRoot
          .querySelector('gr-button');
      assert.isFalse(button.hasAttribute('hidden'));
    });
  });

  suite('Hashtag removal', () => {
    let change;
    setup(() => {
      change = {
        _number: 'the number',
        actions: {
          hashtags: {enabled: false},
        },
        change_id: 'the id',
        hashtags: ['test-hashtag'],
        status: 'NEW',
        submit_type: 'CHERRY_PICK',
        labels: {
          test: {
            all: [{_account_id: 1, name: 'bojack', value: 1}],
            default_value: 0,
            values: [],
          },
        },
        removable_reviewers: [],
      };
    });

    test('_computeHashtagReadOnly', () => {
      flushAsynchronousOperations();
      let mutable = false;
      assert.isTrue(element._computeHashtagReadOnly(mutable, change));
      mutable = true;
      assert.isTrue(element._computeHashtagReadOnly(mutable, change));
      change.actions.hashtags.enabled = true;
      assert.isFalse(element._computeHashtagReadOnly(mutable, change));
      mutable = false;
      assert.isTrue(element._computeHashtagReadOnly(mutable, change));
    });

    test('hashtag read only hides delete button', () => {
      flushAsynchronousOperations();
      element.account = {};
      element.change = change;
      flushAsynchronousOperations();
      const button = element.shadowRoot
          .querySelector('gr-linked-chip').shadowRoot
          .querySelector('gr-button');
      assert.isTrue(button.hasAttribute('hidden'));
    });

    test('hashtag not read only does not hide delete button', () => {
      flushAsynchronousOperations();
      element.account = {test: true};
      change.actions.hashtags.enabled = true;
      element.change = change;
      flushAsynchronousOperations();
      const button = element.shadowRoot
          .querySelector('gr-linked-chip').shadowRoot
          .querySelector('gr-button');
      assert.isFalse(button.hasAttribute('hidden'));
    });
  });

  suite('remove reviewer votes', () => {
    setup(() => {
      sinon.stub(element, '_computeTopicReadOnly').returns(true);
      element.change = {
        _number: 42,
        change_id: 'the id',
        actions: [],
        topic: 'the topic',
        status: 'NEW',
        submit_type: 'CHERRY_PICK',
        labels: {
          test: {
            all: [{_account_id: 1, name: 'bojack', value: 1}],
            default_value: 0,
            values: [],
          },
        },
        removable_reviewers: [],
      };
      flushAsynchronousOperations();
    });

    suite('assignee field', () => {
      const dummyAccount = {
        _account_id: 1,
        name: 'bojack',
      };
      const change = {
        actions: {
          assignee: {enabled: false},
        },
        assignee: dummyAccount,
      };
      let deleteStub;
      let setStub;

      setup(() => {
        deleteStub = sinon.stub(element.$.restAPI, 'deleteAssignee');
        setStub = sinon.stub(element.$.restAPI, 'setAssignee');
        element.serverConfig = {
          change: {
            enable_assignee: true,
          },
        };
      });

      test('changing change recomputes _assignee', () => {
        assert.isFalse(!!element._assignee.length);
        const change = element.change;
        change.assignee = dummyAccount;
        element._changeChanged(change);
        assert.deepEqual(element._assignee[0], dummyAccount);
      });

      test('modifying _assignee calls API', () => {
        assert.isFalse(!!element._assignee.length);
        element.set('_assignee', [dummyAccount]);
        assert.isTrue(setStub.calledOnce);
        assert.deepEqual(element.change.assignee, dummyAccount);
        element.set('_assignee', [dummyAccount]);
        assert.isTrue(setStub.calledOnce);
        element.set('_assignee', []);
        assert.isTrue(deleteStub.calledOnce);
        assert.equal(element.change.assignee, undefined);
        element.set('_assignee', []);
        assert.isTrue(deleteStub.calledOnce);
      });

      test('_computeAssigneeReadOnly', () => {
        let mutable = false;
        assert.isTrue(element._computeAssigneeReadOnly(mutable, change));
        mutable = true;
        assert.isTrue(element._computeAssigneeReadOnly(mutable, change));
        change.actions.assignee.enabled = true;
        assert.isFalse(element._computeAssigneeReadOnly(mutable, change));
        mutable = false;
        assert.isTrue(element._computeAssigneeReadOnly(mutable, change));
      });
    });

    test('changing topic', () => {
      const newTopic = 'the new topic';
      sinon.stub(element.$.restAPI, 'setChangeTopic').returns(
          Promise.resolve(newTopic));
      element._handleTopicChanged({}, newTopic);
      const topicChangedSpy = sinon.spy();
      element.addEventListener('topic-changed', topicChangedSpy);
      assert.isTrue(element.$.restAPI.setChangeTopic.calledWith(
          42, newTopic));
      return element.$.restAPI.setChangeTopic.lastCall.returnValue
          .then(() => {
            assert.equal(element.change.topic, newTopic);
            assert.isTrue(topicChangedSpy.called);
          });
    });

    test('topic removal', () => {
      sinon.stub(element.$.restAPI, 'setChangeTopic').returns(
          Promise.resolve());
      const chip = element.shadowRoot
          .querySelector('gr-linked-chip');
      const remove = chip.$.remove;
      const topicChangedSpy = sinon.spy();
      element.addEventListener('topic-changed', topicChangedSpy);
      MockInteractions.tap(remove);
      assert.isTrue(chip.disabled);
      assert.isTrue(element.$.restAPI.setChangeTopic.calledWith(
          42, null));
      return element.$.restAPI.setChangeTopic.lastCall.returnValue
          .then(() => {
            assert.isFalse(chip.disabled);
            assert.equal(element.change.topic, '');
            assert.isTrue(topicChangedSpy.called);
          });
    });

    test('changing hashtag', () => {
      flushAsynchronousOperations();
      element._newHashtag = 'new hashtag';
      const newHashtag = ['new hashtag'];
      sinon.stub(element.$.restAPI, 'setChangeHashtag').returns(
          Promise.resolve(newHashtag));
      element._handleHashtagChanged({}, 'new hashtag');
      assert.isTrue(element.$.restAPI.setChangeHashtag.calledWith(
          42, {add: ['new hashtag']}));
      return element.$.restAPI.setChangeHashtag.lastCall.returnValue
          .then(() => {
            assert.equal(element.change.hashtags, newHashtag);
          });
    });
  });

  test('editTopic', () => {
    element.account = {test: true};
    element.change = {actions: {topic: {enabled: true}}};
    flushAsynchronousOperations();

    const label = element.shadowRoot
        .querySelector('.topicEditableLabel');
    assert.ok(label);
    sinon.stub(label, 'open');
    element.editTopic();
    flushAsynchronousOperations();

    assert.isTrue(label.open.called);
  });

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