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

import '../../../test/common-test-setup-karma';
import './gr-router';
import {page} from '../../../utils/page-wrapper-utils';
import {
  GenerateUrlChangeViewParameters,
  GenerateUrlDashboardViewParameters,
  GenerateUrlDiffViewParameters,
  GenerateUrlEditViewParameters,
  GenerateUrlGroupViewParameters,
  GenerateUrlParameters,
  GenerateUrlSearchViewParameters,
  GerritNav,
  GroupDetailView,
  WeblinkType,
} from '../gr-navigation/gr-navigation';
import {
  stubBaseUrl,
  stubRestApi,
  addListenerForTest,
} from '../../../test/test-utils';
import {
  GrRouter,
  PageContextWithQueryMap,
  PatchRangeParams,
  _testOnly_RoutePattern,
} from './gr-router';
import {GerritView} from '../../../services/router/router-model';
import {
  BasePatchSetNum,
  BranchName,
  CommitId,
  DashboardId,
  GroupId,
  NumericChangeId,
  ParentPatchSetNum,
  PatchSetNum,
  RepoName,
  RevisionPatchSetNum,
  TopicName,
  UrlEncodedCommentId,
  WebLinkInfo,
} from '../../../types/common';
import {
  createGerritInfo,
  createServerInfo,
} from '../../../test/test-data-generators';
import {AppElementParams} from '../../gr-app-types';

const basicFixture = fixtureFromElement('gr-router');

suite('gr-router tests', () => {
  let element: GrRouter;

  setup(() => {
    element = basicFixture.instantiate();
  });

  test('_firstCodeBrowserWeblink', () => {
    assert.deepEqual(
      element._firstCodeBrowserWeblink([
        {name: 'gitweb'},
        {name: 'gitiles'},
        {name: 'browse'},
        {name: 'test'},
      ]),
      {name: 'gitiles'}
    );

    assert.deepEqual(
      element._firstCodeBrowserWeblink([{name: 'gitweb'}, {name: 'test'}]),
      {name: 'gitweb'}
    );
  });

  test('_getBrowseCommitWeblink', () => {
    const browserLink = {name: 'browser', url: 'browser/url'};
    const link = {name: 'test', url: 'test/url'};
    const weblinks = [browserLink, link];
    const config = {
      ...createServerInfo(),
      gerrit: {...createGerritInfo(), primary_weblink_name: browserLink.name},
    };
    sinon.stub(element, '_firstCodeBrowserWeblink').returns(link);

    assert.deepEqual(
      element._getBrowseCommitWeblink(weblinks, config),
      browserLink
    );

    assert.deepEqual(element._getBrowseCommitWeblink(weblinks), link);
  });

  test('_getChangeWeblinks', () => {
    const link = {name: 'test', url: 'test/url'};
    const browserLink = {name: 'browser', url: 'browser/url'};
    const mapLinksToConfig = (weblinks: WebLinkInfo[]) => {
      return {
        type: 'change' as WeblinkType.CHANGE,
        repo: 'test' as RepoName,
        commit: '111' as CommitId,
        options: {weblinks},
      };
    };
    sinon.stub(element, '_getBrowseCommitWeblink').returns(browserLink);

    assert.deepEqual(
      element._getChangeWeblinks(mapLinksToConfig([link, browserLink]))[0],
      {name: 'test', url: 'test/url'}
    );

    assert.deepEqual(element._getChangeWeblinks(mapLinksToConfig([link]))[0], {
      name: 'test',
      url: 'test/url',
    });

    link.url = `https://${link.url}`;
    assert.deepEqual(element._getChangeWeblinks(mapLinksToConfig([link]))[0], {
      name: 'test',
      url: 'https://test/url',
    });
  });

  test('_getHashFromCanonicalPath', () => {
    let url = '/foo/bar';
    let hash = element._getHashFromCanonicalPath(url);
    assert.equal(hash, '');

    url = '';
    hash = element._getHashFromCanonicalPath(url);
    assert.equal(hash, '');

    url = '/foo#bar';
    hash = element._getHashFromCanonicalPath(url);
    assert.equal(hash, 'bar');

    url = '/foo#bar#baz';
    hash = element._getHashFromCanonicalPath(url);
    assert.equal(hash, 'bar#baz');

    url = '#foo#bar#baz';
    hash = element._getHashFromCanonicalPath(url);
    assert.equal(hash, 'foo#bar#baz');
  });

  suite('_parseLineAddress', () => {
    test('returns null for empty and invalid hashes', () => {
      let actual = element._parseLineAddress('');
      assert.isNull(actual);

      actual = element._parseLineAddress('foobar');
      assert.isNull(actual);

      actual = element._parseLineAddress('foo123');
      assert.isNull(actual);

      actual = element._parseLineAddress('123bar');
      assert.isNull(actual);
    });

    test('parses correctly', () => {
      let actual = element._parseLineAddress('1234');
      assert.isOk(actual);
      assert.equal(actual!.lineNum, 1234);
      assert.isFalse(actual!.leftSide);

      actual = element._parseLineAddress('a4');
      assert.isOk(actual);
      assert.equal(actual!.lineNum, 4);
      assert.isTrue(actual!.leftSide);

      actual = element._parseLineAddress('b77');
      assert.isOk(actual);
      assert.equal(actual!.lineNum, 77);
      assert.isTrue(actual!.leftSide);
    });
  });

  test('_startRouter requires auth for the right handlers', () => {
    // This test encodes the lists of route handler methods that gr-router
    // automatically checks for authentication before triggering.

    const requiresAuth: any = {};
    const doesNotRequireAuth: any = {};
    sinon.stub(GerritNav, 'setup');
    sinon.stub(page, 'start');
    sinon.stub(page, 'base');
    sinon
      .stub(element, '_mapRoute')
      .callsFake((_pattern, methodName, usesAuth) => {
        if (usesAuth) {
          requiresAuth[methodName] = true;
        } else {
          doesNotRequireAuth[methodName] = true;
        }
      });
    element._startRouter();

    const actualRequiresAuth = Object.keys(requiresAuth);
    actualRequiresAuth.sort();
    const actualDoesNotRequireAuth = Object.keys(doesNotRequireAuth);
    actualDoesNotRequireAuth.sort();

    const shouldRequireAutoAuth = [
      '_handleAgreementsRoute',
      '_handleChangeEditRoute',
      '_handleCreateGroupRoute',
      '_handleCreateProjectRoute',
      '_handleDiffEditRoute',
      '_handleGroupAuditLogRoute',
      '_handleGroupInfoRoute',
      '_handleGroupListFilterOffsetRoute',
      '_handleGroupListFilterRoute',
      '_handleGroupListOffsetRoute',
      '_handleGroupMembersRoute',
      '_handleGroupRoute',
      '_handleGroupSelfRedirectRoute',
      '_handleNewAgreementsRoute',
      '_handlePluginListFilterOffsetRoute',
      '_handlePluginListFilterRoute',
      '_handlePluginListOffsetRoute',
      '_handlePluginListRoute',
      '_handleRepoCommandsRoute',
      '_handleSettingsLegacyRoute',
      '_handleSettingsRoute',
    ];
    assert.deepEqual(actualRequiresAuth, shouldRequireAutoAuth);

    const unauthenticatedHandlers = [
      '_handleBranchListFilterOffsetRoute',
      '_handleBranchListFilterRoute',
      '_handleBranchListOffsetRoute',
      '_handleChangeIdQueryRoute',
      '_handleChangeNumberLegacyRoute',
      '_handleChangeRoute',
      '_handleCommentRoute',
      '_handleCommentsRoute',
      '_handleDiffRoute',
      '_handleDefaultRoute',
      '_handleChangeLegacyRoute',
      '_handleDocumentationRedirectRoute',
      '_handleDocumentationSearchRoute',
      '_handleDocumentationSearchRedirectRoute',
      '_handleLegacyLinenum',
      '_handleImproperlyEncodedPlusRoute',
      '_handlePassThroughRoute',
      '_handleProjectDashboardRoute',
      '_handleLegacyProjectDashboardRoute',
      '_handleProjectsOldRoute',
      '_handleRepoAccessRoute',
      '_handleRepoDashboardsRoute',
      '_handleRepoGeneralRoute',
      '_handleRepoListFilterOffsetRoute',
      '_handleRepoListFilterRoute',
      '_handleRepoListOffsetRoute',
      '_handleRepoRoute',
      '_handleQueryLegacySuffixRoute',
      '_handleQueryRoute',
      '_handleRegisterRoute',
      '_handleTagListFilterOffsetRoute',
      '_handleTagListFilterRoute',
      '_handleTagListOffsetRoute',
      '_handlePluginScreen',
    ];

    // Handler names that check authentication themselves, and thus don't need
    // it performed for them.
    const selfAuthenticatingHandlers = [
      '_handleDashboardRoute',
      '_handleCustomDashboardRoute',
      '_handleRootRoute',
    ];

    const shouldNotRequireAuth = unauthenticatedHandlers.concat(
      selfAuthenticatingHandlers
    );
    shouldNotRequireAuth.sort();
    assert.deepEqual(actualDoesNotRequireAuth, shouldNotRequireAuth);
  });

  test('_redirectIfNotLoggedIn while logged in', () => {
    stubRestApi('getLoggedIn').returns(Promise.resolve(true));
    const data = {
      save() {},
      handled: true,
      canonicalPath: '',
      path: '',
      querystring: '',
      pathname: '',
      state: '',
      title: '',
      hash: '',
      params: {test: 'test'},
    };
    const redirectStub = sinon.stub(element, '_redirectToLogin');
    return element._redirectIfNotLoggedIn(data).then(() => {
      assert.isFalse(redirectStub.called);
    });
  });

  test('_redirectIfNotLoggedIn while logged out', () => {
    stubRestApi('getLoggedIn').returns(Promise.resolve(false));
    const redirectStub = sinon.stub(element, '_redirectToLogin');
    const data = {
      save() {},
      handled: true,
      canonicalPath: '',
      path: '',
      querystring: '',
      pathname: '',
      state: '',
      title: '',
      hash: '',
      params: {test: 'test'},
    };
    return new Promise(resolve => {
      element
        ._redirectIfNotLoggedIn(data)
        .then(() => {
          assert.isTrue(false, 'Should never execute');
        })
        .catch(() => {
          assert.isTrue(redirectStub.calledOnce);
          resolve(Promise.resolve());
        });
    });
  });

  suite('generateUrl', () => {
    test('search', () => {
      let params: GenerateUrlSearchViewParameters = {
        view: GerritView.SEARCH,
        owner: 'a%b',
        project: 'c%d' as RepoName,
        branch: 'e%f' as BranchName,
        topic: 'g%h' as TopicName,
        statuses: ['op%en'],
      };
      assert.equal(
        element._generateUrl(params),
        '/q/owner:a%2525b+project:c%2525d+branch:e%2525f+' +
          'topic:g%2525h+status:op%2525en'
      );

      params.offset = 100;
      assert.equal(
        element._generateUrl(params),
        '/q/owner:a%2525b+project:c%2525d+branch:e%2525f+' +
          'topic:g%2525h+status:op%2525en,100'
      );
      delete params.offset;

      // The presence of the query param overrides other params.
      params.query = 'foo$bar';
      assert.equal(element._generateUrl(params), '/q/foo%2524bar');

      params.offset = 100;
      assert.equal(element._generateUrl(params), '/q/foo%2524bar,100');

      params = {
        view: GerritNav.View.SEARCH,
        statuses: ['a', 'b', 'c'],
      };
      assert.equal(
        element._generateUrl(params),
        '/q/(status:a OR status:b OR status:c)'
      );

      params = {
        view: GerritNav.View.SEARCH,
        topic: 'test' as TopicName,
      };
      assert.equal(element._generateUrl(params), '/q/topic:test');
      params = {
        view: GerritNav.View.SEARCH,
        topic: 'test test' as TopicName,
      };
      assert.equal(element._generateUrl(params), '/q/topic:"test+test"');
      params = {
        view: GerritNav.View.SEARCH,
        topic: 'test:test' as TopicName,
      };
      assert.equal(element._generateUrl(params), '/q/topic:"test:test"');
    });

    test('change', () => {
      const params: GenerateUrlChangeViewParameters = {
        view: GerritView.CHANGE,
        changeNum: 1234 as NumericChangeId,
        project: 'test' as RepoName,
      };

      assert.equal(element._generateUrl(params), '/c/test/+/1234');

      params.patchNum = 10 as PatchSetNum;
      assert.equal(element._generateUrl(params), '/c/test/+/1234/10');

      params.basePatchNum = 5 as BasePatchSetNum;
      assert.equal(element._generateUrl(params), '/c/test/+/1234/5..10');

      params.messageHash = '#123';
      assert.equal(element._generateUrl(params), '/c/test/+/1234/5..10#123');
    });

    test('change with repo name encoding', () => {
      const params: GenerateUrlChangeViewParameters = {
        view: GerritView.CHANGE,
        changeNum: 1234 as NumericChangeId,
        project: 'x+/y+/z+/w' as RepoName,
      };
      assert.equal(
        element._generateUrl(params),
        '/c/x%252B/y%252B/z%252B/w/+/1234'
      );
    });

    test('diff', () => {
      const params: GenerateUrlDiffViewParameters = {
        view: GerritView.DIFF,
        changeNum: 42 as NumericChangeId,
        path: 'x+y/path.cpp' as RepoName,
        patchNum: 12 as PatchSetNum,
        project: '' as RepoName,
      };
      assert.equal(element._generateUrl(params), '/c/42/12/x%252By/path.cpp');

      params.project = 'test' as RepoName;
      assert.equal(
        element._generateUrl(params),
        '/c/test/+/42/12/x%252By/path.cpp'
      );

      params.basePatchNum = 6 as BasePatchSetNum;
      assert.equal(
        element._generateUrl(params),
        '/c/test/+/42/6..12/x%252By/path.cpp'
      );

      params.path = 'foo bar/my+file.txt%';
      params.patchNum = 2 as PatchSetNum;
      delete params.basePatchNum;
      assert.equal(
        element._generateUrl(params),
        '/c/test/+/42/2/foo+bar/my%252Bfile.txt%2525'
      );

      params.path = 'file.cpp';
      params.lineNum = 123;
      assert.equal(element._generateUrl(params), '/c/test/+/42/2/file.cpp#123');

      params.leftSide = true;
      assert.equal(
        element._generateUrl(params),
        '/c/test/+/42/2/file.cpp#b123'
      );
    });

    test('diff with repo name encoding', () => {
      const params: GenerateUrlDiffViewParameters = {
        view: GerritView.DIFF,
        changeNum: 42 as NumericChangeId,
        path: 'x+y/path.cpp',
        patchNum: 12 as PatchSetNum,
        project: 'x+/y' as RepoName,
      };
      assert.equal(
        element._generateUrl(params),
        '/c/x%252B/y/+/42/12/x%252By/path.cpp'
      );
    });

    test('edit', () => {
      const params: GenerateUrlEditViewParameters = {
        view: GerritView.EDIT,
        changeNum: 42 as NumericChangeId,
        project: 'test' as RepoName,
        path: 'x+y/path.cpp',
        patchNum: 'edit' as PatchSetNum,
      };
      assert.equal(
        element._generateUrl(params),
        '/c/test/+/42/edit/x%252By/path.cpp,edit'
      );
    });

    test('_getPatchRangeExpression', () => {
      const params: PatchRangeParams = {};
      let actual = element._getPatchRangeExpression(params);
      assert.equal(actual, '');

      params.patchNum = 4 as PatchSetNum;
      actual = element._getPatchRangeExpression(params);
      assert.equal(actual, '4');

      params.basePatchNum = 2 as BasePatchSetNum;
      actual = element._getPatchRangeExpression(params);
      assert.equal(actual, '2..4');

      delete params.patchNum;
      actual = element._getPatchRangeExpression(params);
      assert.equal(actual, '2..');
    });

    suite('dashboard', () => {
      test('self dashboard', () => {
        const params: GenerateUrlDashboardViewParameters = {
          view: GerritView.DASHBOARD,
        };
        assert.equal(element._generateUrl(params), '/dashboard/self');
      });

      test('user dashboard', () => {
        const params: GenerateUrlDashboardViewParameters = {
          view: GerritView.DASHBOARD,
          user: 'user',
        };
        assert.equal(element._generateUrl(params), '/dashboard/user');
      });

      test('custom self dashboard, no title', () => {
        const params: GenerateUrlDashboardViewParameters = {
          view: GerritView.DASHBOARD,
          sections: [
            {name: 'section 1', query: 'query 1'},
            {name: 'section 2', query: 'query 2'},
          ],
        };
        assert.equal(
          element._generateUrl(params),
          '/dashboard/?section%201=query%201&section%202=query%202'
        );
      });

      test('custom repo dashboard', () => {
        const params: GenerateUrlDashboardViewParameters = {
          view: GerritView.DASHBOARD,
          sections: [
            {name: 'section 1', query: 'query 1 ${project}'},
            {name: 'section 2', query: 'query 2 ${repo}'},
          ],
          repo: 'repo-name' as RepoName,
        };
        assert.equal(
          element._generateUrl(params),
          '/dashboard/?section%201=query%201%20repo-name&' +
            'section%202=query%202%20repo-name'
        );
      });

      test('custom user dashboard, with title', () => {
        const params: GenerateUrlDashboardViewParameters = {
          view: GerritView.DASHBOARD,
          user: 'user',
          sections: [{name: 'name', query: 'query'}],
          title: 'custom dashboard',
        };
        assert.equal(
          element._generateUrl(params),
          '/dashboard/user?name=query&title=custom%20dashboard'
        );
      });

      test('repo dashboard', () => {
        const params: GenerateUrlDashboardViewParameters = {
          view: GerritView.DASHBOARD,
          repo: 'gerrit/repo' as RepoName,
          dashboard: 'default:main' as DashboardId,
        };
        assert.equal(
          element._generateUrl(params),
          '/p/gerrit/repo/+/dashboard/default:main'
        );
      });

      test('project dashboard (legacy)', () => {
        const params: GenerateUrlDashboardViewParameters = {
          view: GerritView.DASHBOARD,
          project: 'gerrit/project' as RepoName,
          dashboard: 'default:main' as DashboardId,
        };
        assert.equal(
          element._generateUrl(params),
          '/p/gerrit/project/+/dashboard/default:main'
        );
      });
    });

    suite('groups', () => {
      test('group info', () => {
        const params: GenerateUrlGroupViewParameters = {
          view: GerritView.GROUP,
          groupId: '1234' as GroupId,
        };
        assert.equal(element._generateUrl(params), '/admin/groups/1234');
      });

      test('group members', () => {
        const params: GenerateUrlGroupViewParameters = {
          view: GerritView.GROUP,
          groupId: '1234' as GroupId,
          detail: 'members' as GroupDetailView,
        };
        assert.equal(
          element._generateUrl(params),
          '/admin/groups/1234,members'
        );
      });

      test('group audit log', () => {
        const params: GenerateUrlGroupViewParameters = {
          view: GerritView.GROUP,
          groupId: '1234' as GroupId,
          detail: 'log' as GroupDetailView,
        };
        assert.equal(
          element._generateUrl(params),
          '/admin/groups/1234,audit-log'
        );
      });
    });
  });

  suite('param normalization', () => {
    suite('_normalizePatchRangeParams', () => {
      test('range n..n normalizes to n', () => {
        const params: PatchRangeParams = {
          basePatchNum: 4 as BasePatchSetNum,
          patchNum: 4 as PatchSetNum,
        };
        const needsRedirect = element._normalizePatchRangeParams(params);
        assert.isTrue(needsRedirect);
        assert.equal(params.basePatchNum, ParentPatchSetNum);
        assert.equal(params.patchNum, 4 as PatchSetNum);
      });

      test('range n.. normalizes to n', () => {
        const params: PatchRangeParams = {basePatchNum: 4 as BasePatchSetNum};
        const needsRedirect = element._normalizePatchRangeParams(params);
        assert.isFalse(needsRedirect);
        assert.equal(params.basePatchNum, ParentPatchSetNum);
        assert.equal(params.patchNum, 4 as PatchSetNum);
      });
    });
  });

  suite('route handlers', () => {
    let redirectStub: sinon.SinonStub;
    let setParamsStub: sinon.SinonStub;
    let handlePassThroughRoute: sinon.SinonStub;

    // Simple route handlers are direct mappings from parsed route data to a
    // new set of app.params. This test helper asserts that passing `data`
    // into `methodName` results in setting the params specified in `params`.
    function assertDataToParams(
      data: PageContextWithQueryMap,
      methodName: string,
      params: AppElementParams | GenerateUrlParameters
    ) {
      (element as any)[methodName](data);
      assert.deepEqual(setParamsStub.lastCall.args[0], params);
    }

    function createPageContext(): PageContextWithQueryMap {
      return {
        queryMap: new Map(),
        save() {},
        handled: true,
        canonicalPath: '',
        path: '',
        querystring: '',
        pathname: '',
        state: '',
        title: '',
        hash: '',
        params: {},
      };
    }

    setup(() => {
      redirectStub = sinon.stub(element, '_redirect');
      setParamsStub = sinon.stub(element, '_setParams');
      handlePassThroughRoute = sinon.stub(element, '_handlePassThroughRoute');
    });

    test('_handleLegacyProjectDashboardRoute', () => {
      const params = {
        ...createPageContext(),
        params: {0: 'gerrit/project', 1: 'dashboard:main'},
      };
      element._handleLegacyProjectDashboardRoute(params);
      assert.isTrue(redirectStub.calledOnce);
      assert.equal(
        redirectStub.lastCall.args[0],
        '/p/gerrit/project/+/dashboard/dashboard:main'
      );
    });

    test('_handleAgreementsRoute', () => {
      element._handleAgreementsRoute();
      assert.isTrue(redirectStub.calledOnce);
      assert.equal(redirectStub.lastCall.args[0], '/settings/#Agreements');
    });

    test('_handleNewAgreementsRoute', () => {
      const params = createPageContext();
      element._handleNewAgreementsRoute(params);
      assert.isTrue(setParamsStub.calledOnce);
      assert.equal(
        setParamsStub.lastCall.args[0].view,
        GerritNav.View.AGREEMENTS
      );
    });

    test('_handleSettingsLegacyRoute', () => {
      const data = {...createPageContext(), params: {0: 'my-token'}};
      assertDataToParams(data, '_handleSettingsLegacyRoute', {
        view: GerritNav.View.SETTINGS,
        emailToken: 'my-token',
      });
    });

    test('_handleSettingsLegacyRoute with +', () => {
      const data = {...createPageContext(), params: {0: 'my-token test'}};
      assertDataToParams(data, '_handleSettingsLegacyRoute', {
        view: GerritNav.View.SETTINGS,
        emailToken: 'my-token+test',
      });
    });

    test('_handleSettingsRoute', () => {
      const data = createPageContext();
      assertDataToParams(data, '_handleSettingsRoute', {
        view: GerritNav.View.SETTINGS,
      });
    });

    test('_handleDefaultRoute on first load', () => {
      const spy = sinon.spy();
      addListenerForTest(document, 'page-error', spy);
      element._handleDefaultRoute();
      assert.isTrue(spy.calledOnce);
      assert.equal(spy.lastCall.args[0].detail.response.status, 404);
    });

    test('_handleDefaultRoute after internal navigation', () => {
      let onExit: Function | null = null;
      const onRegisteringExit = (
        _match: string | RegExp,
        _onExit: Function
      ) => {
        onExit = _onExit;
      };
      sinon.stub(page, 'exit').callsFake(onRegisteringExit);
      sinon.stub(GerritNav, 'setup');
      sinon.stub(page, 'start');
      sinon.stub(page, 'base');
      element._startRouter();

      element._handleDefaultRoute();

      onExit!('', () => {}); // we left page;

      element._handleDefaultRoute();
      assert.isTrue(handlePassThroughRoute.calledOnce);
    });

    test('_handleImproperlyEncodedPlusRoute', () => {
      const params = {
        ...createPageContext(),
        canonicalPath: '/c/test/%20/42',
        params: {0: 'test', 1: '42'},
      };
      // Regression test for Issue 7100.
      element._handleImproperlyEncodedPlusRoute(params);
      assert.isTrue(redirectStub.calledOnce);
      assert.equal(redirectStub.lastCall.args[0], '/c/test/+/42');

      sinon.stub(element, '_getHashFromCanonicalPath').returns('foo');
      element._handleImproperlyEncodedPlusRoute(params);
      assert.equal(redirectStub.lastCall.args[0], '/c/test/+/42#foo');
    });

    test('_handleQueryRoute', () => {
      const data: PageContextWithQueryMap = {
        ...createPageContext(),
        params: {0: 'project:foo/bar/baz'},
      };
      assertDataToParams(data, '_handleQueryRoute', {
        view: GerritNav.View.SEARCH,
        query: 'project:foo/bar/baz',
        offset: undefined,
      });

      data.params[1] = '123';
      data.params[2] = '123';
      assertDataToParams(data, '_handleQueryRoute', {
        view: GerritNav.View.SEARCH,
        query: 'project:foo/bar/baz',
        offset: '123',
      });
    });

    test('_handleQueryLegacySuffixRoute', () => {
      const params = {...createPageContext(), path: '/q/foo+bar,n,z'};
      element._handleQueryLegacySuffixRoute(params);
      assert.isTrue(redirectStub.calledOnce);
      assert.equal(redirectStub.lastCall.args[0], '/q/foo+bar');
    });

    test('_handleChangeIdQueryRoute', () => {
      const data = {
        ...createPageContext(),
        params: {0: 'I0123456789abcdef0123456789abcdef01234567'},
      };
      assertDataToParams(data, '_handleChangeIdQueryRoute', {
        view: GerritNav.View.SEARCH,
        query: 'I0123456789abcdef0123456789abcdef01234567',
      });
    });

    suite('_handleRegisterRoute', () => {
      test('happy path', () => {
        const ctx = {...createPageContext(), params: {0: '/foo/bar'}};
        element._handleRegisterRoute(ctx);
        assert.isTrue(redirectStub.calledWithExactly('/foo/bar'));
        assert.isTrue(setParamsStub.calledOnce);
        assert.isTrue(setParamsStub.lastCall.args[0].justRegistered);
      });

      test('no param', () => {
        const ctx = createPageContext();
        element._handleRegisterRoute(ctx);
        assert.isTrue(redirectStub.calledWithExactly('/'));
        assert.isTrue(setParamsStub.calledOnce);
        assert.isTrue(setParamsStub.lastCall.args[0].justRegistered);
      });

      test('prevent redirect', () => {
        const ctx = {...createPageContext(), params: {0: '/register'}};
        element._handleRegisterRoute(ctx);
        assert.isTrue(redirectStub.calledWithExactly('/'));
        assert.isTrue(setParamsStub.calledOnce);
        assert.isTrue(setParamsStub.lastCall.args[0].justRegistered);
      });
    });

    suite('_handleRootRoute', () => {
      test('closes for closeAfterLogin', () => {
        const data = {...createPageContext(), querystring: 'closeAfterLogin'};
        const closeStub = sinon.stub(window, 'close');
        const result = element._handleRootRoute(data);
        assert.isNotOk(result);
        assert.isTrue(closeStub.called);
        assert.isFalse(redirectStub.called);
      });

      test('redirects to dashboard if logged in', () => {
        const data = {...createPageContext(), canonicalPath: '/', path: '/'};
        const result = element._handleRootRoute(data);
        assert.isOk(result);
        return result!.then(() => {
          assert.isTrue(redirectStub.calledWithExactly('/dashboard/self'));
        });
      });

      test('redirects to open changes if not logged in', () => {
        stubRestApi('getLoggedIn').returns(Promise.resolve(false));
        const data = {...createPageContext(), canonicalPath: '/', path: '/'};
        const result = element._handleRootRoute(data);
        assert.isOk(result);
        return result!.then(() => {
          assert.isTrue(
            redirectStub.calledWithExactly('/q/status:open+-is:wip')
          );
        });
      });

      suite('GWT hash-path URLs', () => {
        test('redirects hash-path URLs', () => {
          const data = {
            ...createPageContext(),
            canonicalPath: '/#/foo/bar/baz',
            hash: '/foo/bar/baz',
          };
          const result = element._handleRootRoute(data);
          assert.isNotOk(result);
          assert.isTrue(redirectStub.called);
          assert.isTrue(redirectStub.calledWithExactly('/foo/bar/baz'));
        });

        test('redirects hash-path URLs w/o leading slash', () => {
          const data = {
            ...createPageContext(),
            canonicalPath: '/#foo/bar/baz',
            hash: 'foo/bar/baz',
          };
          const result = element._handleRootRoute(data);
          assert.isNotOk(result);
          assert.isTrue(redirectStub.called);
          assert.isTrue(redirectStub.calledWithExactly('/foo/bar/baz'));
        });

        test('normalizes "/ /" in hash to "/+/"', () => {
          const data = {
            ...createPageContext(),
            canonicalPath: '/#/foo/bar/+/123/4',
            hash: '/foo/bar/ /123/4',
          };
          const result = element._handleRootRoute(data);
          assert.isNotOk(result);
          assert.isTrue(redirectStub.called);
          assert.isTrue(redirectStub.calledWithExactly('/foo/bar/+/123/4'));
        });

        test('prepends baseurl to hash-path', () => {
          const data = {
            ...createPageContext(),
            canonicalPath: '/#/foo/bar',
            hash: '/foo/bar',
          };
          stubBaseUrl('/baz');
          const result = element._handleRootRoute(data);
          assert.isNotOk(result);
          assert.isTrue(redirectStub.called);
          assert.isTrue(redirectStub.calledWithExactly('/baz/foo/bar'));
        });

        test('normalizes /VE/ settings hash-paths', () => {
          const data = {
            ...createPageContext(),
            canonicalPath: '/#/VE/foo/bar',
            hash: '/VE/foo/bar',
          };
          const result = element._handleRootRoute(data);
          assert.isNotOk(result);
          assert.isTrue(redirectStub.called);
          assert.isTrue(redirectStub.calledWithExactly('/settings/VE/foo/bar'));
        });

        test('does not drop "inner hashes"', () => {
          const data = {
            ...createPageContext(),
            canonicalPath: '/#/foo/bar#baz',
            hash: '/foo/bar',
          };
          const result = element._handleRootRoute(data);
          assert.isNotOk(result);
          assert.isTrue(redirectStub.called);
          assert.isTrue(redirectStub.calledWithExactly('/foo/bar#baz'));
        });
      });
    });

    suite('_handleDashboardRoute', () => {
      let redirectToLoginStub: sinon.SinonStub;

      setup(() => {
        redirectToLoginStub = sinon.stub(element, '_redirectToLogin');
      });

      test('own dashboard but signed out redirects to login', () => {
        stubRestApi('getLoggedIn').returns(Promise.resolve(false));
        const data = {
          ...createPageContext(),
          canonicalPath: '/dashboard/',
          params: {0: 'seLF'},
        };
        return element._handleDashboardRoute(data).then(() => {
          assert.isTrue(redirectToLoginStub.calledOnce);
          assert.isFalse(redirectStub.called);
          assert.isFalse(setParamsStub.called);
        });
      });

      test('non-self dashboard but signed out does not redirect', () => {
        stubRestApi('getLoggedIn').returns(Promise.resolve(false));
        const data = {
          ...createPageContext(),
          canonicalPath: '/dashboard/',
          params: {0: 'foo'},
        };
        return element._handleDashboardRoute(data).then(() => {
          assert.isFalse(redirectToLoginStub.called);
          assert.isFalse(setParamsStub.called);
          assert.isTrue(redirectStub.calledOnce);
          assert.equal(redirectStub.lastCall.args[0], '/q/owner:foo');
        });
      });

      test('dashboard while signed in sets params', () => {
        const data = {
          ...createPageContext(),
          canonicalPath: '/dashboard/',
          params: {0: 'foo'},
        };
        return element._handleDashboardRoute(data).then(() => {
          assert.isFalse(redirectToLoginStub.called);
          assert.isFalse(redirectStub.called);
          assert.isTrue(setParamsStub.calledOnce);
          assert.deepEqual(setParamsStub.lastCall.args[0], {
            view: GerritNav.View.DASHBOARD,
            user: 'foo',
          });
        });
      });
    });

    suite('_handleCustomDashboardRoute', () => {
      let redirectToLoginStub: sinon.SinonStub;

      setup(() => {
        redirectToLoginStub = sinon.stub(element, '_redirectToLogin');
      });

      test('no user specified', () => {
        const data = {
          ...createPageContext(),
          canonicalPath: '/dashboard/',
          params: {0: ''},
        };
        return element._handleCustomDashboardRoute(data, '').then(() => {
          assert.isFalse(setParamsStub.called);
          assert.isTrue(redirectStub.called);
          assert.equal(redirectStub.lastCall.args[0], '/dashboard/self');
        });
      });

      test('custom dashboard without title', () => {
        const data = {
          ...createPageContext(),
          canonicalPath: '/dashboard/',
          params: {0: ''},
        };
        return element
          ._handleCustomDashboardRoute(data, '?a=b&c&d=e')
          .then(() => {
            assert.isFalse(redirectStub.called);
            assert.isTrue(setParamsStub.calledOnce);
            assert.deepEqual(setParamsStub.lastCall.args[0], {
              view: GerritNav.View.DASHBOARD,
              user: 'self',
              sections: [
                {name: 'a', query: 'b'},
                {name: 'd', query: 'e'},
              ],
              title: 'Custom Dashboard',
            });
          });
      });

      test('custom dashboard with title', () => {
        const data = {
          ...createPageContext(),
          canonicalPath: '/dashboard/',
          params: {0: ''},
        };
        return element
          ._handleCustomDashboardRoute(data, '?a=b&c&d=&=e&title=t')
          .then(() => {
            assert.isFalse(redirectToLoginStub.called);
            assert.isFalse(redirectStub.called);
            assert.isTrue(setParamsStub.calledOnce);
            assert.deepEqual(setParamsStub.lastCall.args[0], {
              view: GerritNav.View.DASHBOARD,
              user: 'self',
              sections: [{name: 'a', query: 'b'}],
              title: 't',
            });
          });
      });

      test('custom dashboard with foreach', () => {
        const data = {
          ...createPageContext(),
          canonicalPath: '/dashboard/',
          params: {0: ''},
        };
        return element
          ._handleCustomDashboardRoute(data, '?a=b&c&d=&=e&foreach=is:open')
          .then(() => {
            assert.isFalse(redirectToLoginStub.called);
            assert.isFalse(redirectStub.called);
            assert.isTrue(setParamsStub.calledOnce);
            assert.deepEqual(setParamsStub.lastCall.args[0], {
              view: GerritNav.View.DASHBOARD,
              user: 'self',
              sections: [{name: 'a', query: 'is:open b'}],
              title: 'Custom Dashboard',
            });
          });
      });
    });

    suite('group routes', () => {
      test('_handleGroupInfoRoute', () => {
        const data = {...createPageContext(), params: {0: '1234'}};
        element._handleGroupInfoRoute(data);
        assert.isTrue(redirectStub.calledOnce);
        assert.equal(redirectStub.lastCall.args[0], '/admin/groups/1234');
      });

      test('_handleGroupAuditLogRoute', () => {
        const data = {...createPageContext(), params: {0: '1234'}};
        assertDataToParams(data, '_handleGroupAuditLogRoute', {
          view: GerritView.GROUP,
          detail: GroupDetailView.LOG,
          groupId: '1234' as GroupId,
        });
      });

      test('_handleGroupMembersRoute', () => {
        const data = {...createPageContext(), params: {0: '1234'}};
        assertDataToParams(data, '_handleGroupMembersRoute', {
          view: GerritView.GROUP,
          detail: GroupDetailView.MEMBERS,
          groupId: '1234' as GroupId,
        });
      });

      test('_handleGroupListOffsetRoute', () => {
        const data = createPageContext();
        assertDataToParams(data, '_handleGroupListOffsetRoute', {
          view: GerritView.ADMIN,
          adminView: 'gr-admin-group-list',
          offset: 0,
          filter: null,
          openCreateModal: false,
        });

        data.params[1] = '42';
        assertDataToParams(data, '_handleGroupListOffsetRoute', {
          view: GerritView.ADMIN,
          adminView: 'gr-admin-group-list',
          offset: '42',
          filter: null,
          openCreateModal: false,
        });

        data.hash = 'create';
        assertDataToParams(data, '_handleGroupListOffsetRoute', {
          view: GerritNav.View.ADMIN,
          adminView: 'gr-admin-group-list',
          offset: '42',
          filter: null,
          openCreateModal: true,
        });
      });

      test('_handleGroupListFilterOffsetRoute', () => {
        const data = {
          ...createPageContext(),
          params: {filter: 'foo', offset: '42'},
        };
        assertDataToParams(data, '_handleGroupListFilterOffsetRoute', {
          view: GerritView.ADMIN,
          adminView: 'gr-admin-group-list',
          offset: '42',
          filter: 'foo',
        });
      });

      test('_handleGroupListFilterRoute', () => {
        const data = {...createPageContext(), params: {filter: 'foo'}};
        assertDataToParams(data, '_handleGroupListFilterRoute', {
          view: GerritView.ADMIN,
          adminView: 'gr-admin-group-list',
          filter: 'foo',
        });
      });

      test('_handleGroupRoute', () => {
        const data = {...createPageContext(), params: {0: '4321'}};
        assertDataToParams(data, '_handleGroupRoute', {
          view: GerritView.GROUP,
          groupId: '4321' as GroupId,
        });
      });
    });

    suite('repo routes', () => {
      test('_handleProjectsOldRoute', () => {
        const data = {...createPageContext(), params: {}};
        element._handleProjectsOldRoute(data);
        assert.isTrue(redirectStub.calledOnce);
        assert.equal(redirectStub.lastCall.args[0], '/admin/repos/');
      });

      test('_handleProjectsOldRoute test', () => {
        const data = {...createPageContext(), params: {1: 'test'}};
        element._handleProjectsOldRoute(data);
        assert.isTrue(redirectStub.calledOnce);
        assert.equal(redirectStub.lastCall.args[0], '/admin/repos/test');
      });

      test('_handleProjectsOldRoute test,branches', () => {
        const data = {...createPageContext(), params: {1: 'test,branches'}};
        element._handleProjectsOldRoute(data);
        assert.isTrue(redirectStub.calledOnce);
        assert.equal(
          redirectStub.lastCall.args[0],
          '/admin/repos/test,branches'
        );
      });

      test('_handleRepoRoute', () => {
        const data = {...createPageContext(), path: '/admin/repos/test'};
        element._handleRepoRoute(data);
        assert.isTrue(redirectStub.calledOnce);
        assert.equal(
          redirectStub.lastCall.args[0],
          '/admin/repos/test,general'
        );
      });

      test('_handleRepoGeneralRoute', () => {
        const data = {...createPageContext(), params: {0: '4321'}};
        assertDataToParams(data, '_handleRepoGeneralRoute', {
          view: GerritView.REPO,
          detail: GerritNav.RepoDetailView.GENERAL,
          repo: '4321' as RepoName,
        });
      });

      test('_handleRepoCommandsRoute', () => {
        const data = {...createPageContext(), params: {0: '4321'}};
        assertDataToParams(data, '_handleRepoCommandsRoute', {
          view: GerritView.REPO,
          detail: GerritNav.RepoDetailView.COMMANDS,
          repo: '4321' as RepoName,
        });
      });

      test('_handleRepoAccessRoute', () => {
        const data = {...createPageContext(), params: {0: '4321'}};
        assertDataToParams(data, '_handleRepoAccessRoute', {
          view: GerritView.REPO,
          detail: GerritNav.RepoDetailView.ACCESS,
          repo: '4321' as RepoName,
        });
      });

      suite('branch list routes', () => {
        test('_handleBranchListOffsetRoute', () => {
          const data: PageContextWithQueryMap = {
            ...createPageContext(),
            params: {0: '4321'},
          };
          assertDataToParams(data, '_handleBranchListOffsetRoute', {
            view: GerritView.REPO,
            detail: GerritNav.RepoDetailView.BRANCHES,
            repo: '4321' as RepoName,
            offset: 0,
            filter: null,
          });

          data.params[2] = '42';
          assertDataToParams(data, '_handleBranchListOffsetRoute', {
            view: GerritView.REPO,
            detail: GerritNav.RepoDetailView.BRANCHES,
            repo: '4321' as RepoName,
            offset: '42',
            filter: null,
          });
        });

        test('_handleBranchListFilterOffsetRoute', () => {
          const data = {
            ...createPageContext(),
            params: {repo: '4321', filter: 'foo', offset: '42'},
          };
          assertDataToParams(data, '_handleBranchListFilterOffsetRoute', {
            view: GerritView.REPO,
            detail: GerritNav.RepoDetailView.BRANCHES,
            repo: '4321' as RepoName,
            offset: '42',
            filter: 'foo',
          });
        });

        test('_handleBranchListFilterRoute', () => {
          const data = {
            ...createPageContext(),
            params: {repo: '4321', filter: 'foo'},
          };
          assertDataToParams(data, '_handleBranchListFilterRoute', {
            view: GerritView.REPO,
            detail: GerritNav.RepoDetailView.BRANCHES,
            repo: '4321' as RepoName,
            filter: 'foo',
          });
        });
      });

      suite('tag list routes', () => {
        test('_handleTagListOffsetRoute', () => {
          const data = {...createPageContext(), params: {0: '4321'}};
          assertDataToParams(data, '_handleTagListOffsetRoute', {
            view: GerritView.REPO,
            detail: GerritNav.RepoDetailView.TAGS,
            repo: '4321' as RepoName,
            offset: 0,
            filter: null,
          });
        });

        test('_handleTagListFilterOffsetRoute', () => {
          const data = {
            ...createPageContext(),
            params: {repo: '4321', filter: 'foo', offset: '42'},
          };
          assertDataToParams(data, '_handleTagListFilterOffsetRoute', {
            view: GerritView.REPO,
            detail: GerritNav.RepoDetailView.TAGS,
            repo: '4321' as RepoName,
            offset: '42',
            filter: 'foo',
          });
        });

        test('_handleTagListFilterRoute', () => {
          const data: PageContextWithQueryMap = {
            ...createPageContext(),
            params: {repo: '4321'},
          };
          assertDataToParams(data, '_handleTagListFilterRoute', {
            view: GerritView.REPO,
            detail: GerritNav.RepoDetailView.TAGS,
            repo: '4321' as RepoName,
            filter: null,
          });

          data.params.filter = 'foo';
          assertDataToParams(data, '_handleTagListFilterRoute', {
            view: GerritView.REPO,
            detail: GerritNav.RepoDetailView.TAGS,
            repo: '4321' as RepoName,
            filter: 'foo',
          });
        });
      });

      suite('repo list routes', () => {
        test('_handleRepoListOffsetRoute', () => {
          const data = createPageContext();
          assertDataToParams(data, '_handleRepoListOffsetRoute', {
            view: GerritView.ADMIN,
            adminView: 'gr-repo-list',
            offset: 0,
            filter: null,
            openCreateModal: false,
          });

          data.params[1] = '42';
          assertDataToParams(data, '_handleRepoListOffsetRoute', {
            view: GerritView.ADMIN,
            adminView: 'gr-repo-list',
            offset: '42',
            filter: null,
            openCreateModal: false,
          });

          data.hash = 'create';
          assertDataToParams(data, '_handleRepoListOffsetRoute', {
            view: GerritView.ADMIN,
            adminView: 'gr-repo-list',
            offset: '42',
            filter: null,
            openCreateModal: true,
          });
        });

        test('_handleRepoListFilterOffsetRoute', () => {
          const data = {
            ...createPageContext(),
            params: {filter: 'foo', offset: '42'},
          };
          assertDataToParams(data, '_handleRepoListFilterOffsetRoute', {
            view: GerritView.ADMIN,
            adminView: 'gr-repo-list',
            offset: '42',
            filter: 'foo',
          });
        });

        test('_handleRepoListFilterRoute', () => {
          const data = createPageContext();
          assertDataToParams(data, '_handleRepoListFilterRoute', {
            view: GerritView.ADMIN,
            adminView: 'gr-repo-list',
            filter: null,
          });

          data.params.filter = 'foo';
          assertDataToParams(data, '_handleRepoListFilterRoute', {
            view: GerritView.ADMIN,
            adminView: 'gr-repo-list',
            filter: 'foo',
          });
        });
      });
    });

    suite('plugin routes', () => {
      test('_handlePluginListOffsetRoute', () => {
        const data = createPageContext();
        assertDataToParams(data, '_handlePluginListOffsetRoute', {
          view: GerritView.ADMIN,
          adminView: 'gr-plugin-list',
          offset: 0,
          filter: null,
        });

        data.params[1] = '42';
        assertDataToParams(data, '_handlePluginListOffsetRoute', {
          view: GerritView.ADMIN,
          adminView: 'gr-plugin-list',
          offset: '42',
          filter: null,
        });
      });

      test('_handlePluginListFilterOffsetRoute', () => {
        const data = {
          ...createPageContext(),
          params: {filter: 'foo', offset: '42'},
        };
        assertDataToParams(data, '_handlePluginListFilterOffsetRoute', {
          view: GerritView.ADMIN,
          adminView: 'gr-plugin-list',
          offset: '42',
          filter: 'foo',
        });
      });

      test('_handlePluginListFilterRoute', () => {
        const data = createPageContext();
        assertDataToParams(data, '_handlePluginListFilterRoute', {
          view: GerritView.ADMIN,
          adminView: 'gr-plugin-list',
          filter: null,
        });

        data.params.filter = 'foo';
        assertDataToParams(data, '_handlePluginListFilterRoute', {
          view: GerritView.ADMIN,
          adminView: 'gr-plugin-list',
          filter: 'foo',
        });
      });

      test('_handlePluginListRoute', () => {
        const data = createPageContext();
        assertDataToParams(data, '_handlePluginListRoute', {
          view: GerritView.ADMIN,
          adminView: 'gr-plugin-list',
        });
      });
    });

    suite('change/diff routes', () => {
      test('_handleChangeNumberLegacyRoute', () => {
        const data = {...createPageContext(), params: {0: '12345'}};
        element._handleChangeNumberLegacyRoute(data);
        assert.isTrue(redirectStub.calledOnce);
        assert.isTrue(redirectStub.calledWithExactly('/c/12345'));
      });

      test('_handleChangeLegacyRoute', async () => {
        stubRestApi('getFromProjectLookup').returns(
          Promise.resolve('project' as RepoName)
        );
        const ctx = {
          ...createPageContext(),
          params: {0: '1234', 1: 'comment/6789'},
        };
        element._handleChangeLegacyRoute(ctx);
        await flush();
        assert.isTrue(
          redirectStub.calledWithExactly('/c/project/+/1234' + '/comment/6789')
        );
      });

      test('_handleLegacyLinenum w/ @321', () => {
        const ctx = {...createPageContext(), path: '/c/1234/3..8/foo/bar@321'};
        element._handleLegacyLinenum(ctx);
        assert.isTrue(redirectStub.calledOnce);
        assert.isTrue(
          redirectStub.calledWithExactly('/c/1234/3..8/foo/bar#321')
        );
      });

      test('_handleLegacyLinenum w/ @b123', () => {
        const ctx = {...createPageContext(), path: '/c/1234/3..8/foo/bar@b123'};
        element._handleLegacyLinenum(ctx);
        assert.isTrue(redirectStub.calledOnce);
        assert.isTrue(
          redirectStub.calledWithExactly('/c/1234/3..8/foo/bar#b123')
        );
      });

      suite('_handleChangeRoute', () => {
        let normalizeRangeStub: sinon.SinonStub;

        function makeParams(
          _path: string,
          _hash: string
        ): PageContextWithQueryMap {
          return {
            ...createPageContext(),
            params: {
              0: 'foo/bar', // 0 Project
              1: '1234', // 1 Change number
              2: '', // 2 Unused
              3: '', // 3 Unused
              4: '4', // 4 Base patch number
              5: '', // 5 Unused
              6: '7', // 6 Patch number
            },
          };
        }

        setup(() => {
          normalizeRangeStub = sinon.stub(
            element,
            '_normalizePatchRangeParams'
          );
          stubRestApi('setInProjectLookup');
        });

        test('needs redirect', () => {
          normalizeRangeStub.returns(true);
          sinon.stub(element, '_generateUrl').returns('foo');
          const ctx = makeParams('', '');
          element._handleChangeRoute(ctx);
          assert.isTrue(normalizeRangeStub.called);
          assert.isFalse(setParamsStub.called);
          assert.isTrue(redirectStub.calledOnce);
          assert.isTrue(redirectStub.calledWithExactly('foo'));
        });

        test('change view', () => {
          normalizeRangeStub.returns(false);
          sinon.stub(element, '_generateUrl').returns('foo');
          const ctx = makeParams('', '');
          assertDataToParams(ctx, '_handleChangeRoute', {
            view: GerritView.CHANGE,
            project: 'foo/bar' as RepoName,
            changeNum: 1234 as NumericChangeId,
            basePatchNum: 4 as BasePatchSetNum,
            patchNum: 7 as RevisionPatchSetNum,
          });
          assert.isFalse(redirectStub.called);
          assert.isTrue(normalizeRangeStub.called);
        });

        test('params', () => {
          normalizeRangeStub.returns(false);
          sinon.stub(element, '_generateUrl').returns('foo');
          const ctx = makeParams('', '');
          ctx.queryMap.set('tab', 'checks');
          ctx.queryMap.set('filter', 'fff');
          ctx.queryMap.set('select', 'sss');
          ctx.queryMap.set('attempt', '1');
          assertDataToParams(ctx, '_handleChangeRoute', {
            view: GerritView.CHANGE,
            project: 'foo/bar' as RepoName,
            changeNum: 1234 as NumericChangeId,
            basePatchNum: 4 as BasePatchSetNum,
            patchNum: 7 as RevisionPatchSetNum,
            attempt: 1,
            filter: 'fff',
            select: 'sss',
            tab: 'checks',
          });
        });
      });

      suite('_handleDiffRoute', () => {
        let normalizeRangeStub: sinon.SinonStub;

        function makeParams(
          path: string,
          hash: string
        ): PageContextWithQueryMap {
          return {
            ...createPageContext(),
            hash,
            params: {
              0: 'foo/bar', // 0 Project
              1: '1234', // 1 Change number
              2: '', // 2 Unused
              3: '', // 3 Unused
              4: '4', // 4 Base patch number
              5: '', // 5 Unused
              6: '7', // 6 Patch number
              7: '', // 7 Unused,
              8: path, // 8 Diff path
            },
          };
        }

        setup(() => {
          normalizeRangeStub = sinon.stub(
            element,
            '_normalizePatchRangeParams'
          );
          stubRestApi('setInProjectLookup');
        });

        test('needs redirect', () => {
          normalizeRangeStub.returns(true);
          sinon.stub(element, '_generateUrl').returns('foo');
          const ctx = makeParams('', '');
          element._handleDiffRoute(ctx);
          assert.isTrue(normalizeRangeStub.called);
          assert.isFalse(setParamsStub.called);
          assert.isTrue(redirectStub.calledOnce);
          assert.isTrue(redirectStub.calledWithExactly('foo'));
        });

        test('diff view', () => {
          normalizeRangeStub.returns(false);
          sinon.stub(element, '_generateUrl').returns('foo');
          const ctx = makeParams('foo/bar/baz', 'b44');
          assertDataToParams(ctx, '_handleDiffRoute', {
            view: GerritView.DIFF,
            project: 'foo/bar' as RepoName,
            changeNum: 1234 as NumericChangeId,
            basePatchNum: 4 as BasePatchSetNum,
            patchNum: 7 as RevisionPatchSetNum,
            path: 'foo/bar/baz',
            leftSide: true,
            lineNum: 44,
          });
          assert.isFalse(redirectStub.called);
          assert.isTrue(normalizeRangeStub.called);
        });

        test('comment route', () => {
          const url = '/c/gerrit/+/264833/comment/00049681_f34fd6a9/';
          const groups = url.match(_testOnly_RoutePattern.COMMENT);
          assert.deepEqual(groups!.slice(1), [
            'gerrit', // project
            '264833', // changeNum
            '00049681_f34fd6a9', // commentId
          ]);
          assertDataToParams(
            {params: groups!.slice(1)} as any,
            '_handleCommentRoute',
            {
              project: 'gerrit' as RepoName,
              changeNum: 264833 as NumericChangeId,
              commentId: '00049681_f34fd6a9' as UrlEncodedCommentId,
              commentLink: true,
              view: GerritView.DIFF,
            }
          );
        });

        test('comments route', () => {
          const url = '/c/gerrit/+/264833/comments/00049681_f34fd6a9/';
          const groups = url.match(_testOnly_RoutePattern.COMMENTS_TAB);
          assert.deepEqual(groups!.slice(1), [
            'gerrit', // project
            '264833', // changeNum
            '00049681_f34fd6a9', // commentId
          ]);
          assertDataToParams(
            {params: groups!.slice(1)} as any,
            '_handleCommentsRoute',
            {
              project: 'gerrit' as RepoName,
              changeNum: 264833 as NumericChangeId,
              commentId: '00049681_f34fd6a9' as UrlEncodedCommentId,
              view: GerritView.CHANGE,
            }
          );
        });
      });

      test('_handleDiffEditRoute', () => {
        const normalizeRangeSpy = sinon.spy(
          element,
          '_normalizePatchRangeParams'
        );
        stubRestApi('setInProjectLookup');
        const ctx = {
          ...createPageContext(),
          hash: '',
          params: {
            0: 'foo/bar', // 0 Project
            1: '1234', // 1 Change number
            2: '3', // 2 Patch num
            3: 'foo/bar/baz', // 3 File path
          },
        };
        const appParams: GenerateUrlEditViewParameters = {
          project: 'foo/bar' as RepoName,
          changeNum: 1234 as NumericChangeId,
          view: GerritNav.View.EDIT,
          path: 'foo/bar/baz',
          patchNum: 3 as PatchSetNum,
          lineNum: '',
        };

        element._handleDiffEditRoute(ctx);
        assert.isFalse(redirectStub.called);
        assert.isTrue(normalizeRangeSpy.calledOnce);
        assert.deepEqual(normalizeRangeSpy.lastCall.args[0], appParams);
        assert.isFalse(normalizeRangeSpy.lastCall.returnValue);
        assert.deepEqual(setParamsStub.lastCall.args[0], appParams);
      });

      test('_handleDiffEditRoute with lineNum', () => {
        const normalizeRangeSpy = sinon.spy(
          element,
          '_normalizePatchRangeParams'
        );
        stubRestApi('setInProjectLookup');
        const ctx = {
          ...createPageContext(),
          hash: '4',
          params: {
            0: 'foo/bar', // 0 Project
            1: '1234', // 1 Change number
            2: '3', // 2 Patch num
            3: 'foo/bar/baz', // 3 File path
          },
        };
        const appParams: GenerateUrlEditViewParameters = {
          project: 'foo/bar' as RepoName,
          changeNum: 1234 as NumericChangeId,
          view: GerritNav.View.EDIT,
          path: 'foo/bar/baz',
          patchNum: 3 as PatchSetNum,
          lineNum: '4',
        };

        element._handleDiffEditRoute(ctx);
        assert.isFalse(redirectStub.called);
        assert.isTrue(normalizeRangeSpy.calledOnce);
        assert.deepEqual(normalizeRangeSpy.lastCall.args[0], appParams);
        assert.isFalse(normalizeRangeSpy.lastCall.returnValue);
        assert.deepEqual(setParamsStub.lastCall.args[0], appParams);
      });

      test('_handleChangeEditRoute', () => {
        const normalizeRangeSpy = sinon.spy(
          element,
          '_normalizePatchRangeParams'
        );
        stubRestApi('setInProjectLookup');
        const ctx = {
          ...createPageContext(),
          params: {
            0: 'foo/bar', // 0 Project
            1: '1234', // 1 Change number
            2: '',
            3: '3', // 3 Patch num
          },
        };
        const appParams: GenerateUrlChangeViewParameters = {
          project: 'foo/bar' as RepoName,
          changeNum: 1234 as NumericChangeId,
          view: GerritView.CHANGE,
          patchNum: 3 as PatchSetNum,
          edit: true,
          tab: '',
        };

        element._handleChangeEditRoute(ctx);
        assert.isFalse(redirectStub.called);
        assert.isTrue(normalizeRangeSpy.calledOnce);
        assert.deepEqual(normalizeRangeSpy.lastCall.args[0], appParams);
        assert.isFalse(normalizeRangeSpy.lastCall.returnValue);
        assert.deepEqual(setParamsStub.lastCall.args[0], appParams);
      });
    });

    test('_handlePluginScreen', () => {
      const ctx = {...createPageContext(), params: {0: 'foo', 1: 'bar'}};
      assertDataToParams(ctx, '_handlePluginScreen', {
        view: GerritNav.View.PLUGIN_SCREEN,
        plugin: 'foo',
        screen: 'bar',
      });
      assert.isFalse(redirectStub.called);
    });
  });

  suite('_parseQueryString', () => {
    test('empty queries', () => {
      assert.deepEqual(element._parseQueryString(''), []);
      assert.deepEqual(element._parseQueryString('?'), []);
      assert.deepEqual(element._parseQueryString('??'), []);
      assert.deepEqual(element._parseQueryString('&&&'), []);
    });

    test('url decoding', () => {
      assert.deepEqual(element._parseQueryString('+'), [[' ', '']]);
      assert.deepEqual(element._parseQueryString('???+%3d+'), [[' = ', '']]);
      assert.deepEqual(
        element._parseQueryString('%6e%61%6d%65=%76%61%6c%75%65'),
        [['name', 'value']]
      );
    });

    test('multiple parameters', () => {
      assert.deepEqual(element._parseQueryString('a=b&c=d&e=f'), [
        ['a', 'b'],
        ['c', 'd'],
        ['e', 'f'],
      ]);
      assert.deepEqual(element._parseQueryString('&a=b&&&e=f&c'), [
        ['a', 'b'],
        ['e', 'f'],
        ['c', ''],
      ]);
    });
  });
});