vcs: don't use deprecated get_changeset[s] methods.

rhodecode/api/tests/test_comment_commit.py

@@ -1,81 +1,81 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 
 from rhodecode.model.db import ChangesetStatus
 from rhodecode.api.tests.utils import (
     build_data, api_call, assert_error, assert_ok)
 
 
 @pytest.mark.usefixtures("testuser_api", "app")
 class TestCommentCommit(object):
     def test_api_comment_commit_on_empty_repo(self, backend):
         repo = backend.create_repo()
         id_, params = build_data(
             self.apikey, 'comment_commit', repoid=repo.repo_name,
             commit_id='tip', message='message', status_change=None)
         response = api_call(self.app, params)
         expected = 'There are no commits yet'
         assert_error(id_, expected, given=response.body)
 
     @pytest.mark.parametrize("commit_id, expected_err", [
         ('abcabca', {'hg': 'Commit {commit} does not exist for {repo}',
                      'git': 'Commit {commit} does not exist for {repo}',
                      'svn': 'Commit id {commit} not understood.'}),
         ('idontexist', {'hg': 'Commit {commit} does not exist for {repo}',
                         'git': 'Commit {commit} does not exist for {repo}',
                         'svn': 'Commit id {commit} not understood.'}),
     ])
     def test_api_comment_commit_wrong_hash(self, backend, commit_id, expected_err):
         repo_name = backend.repo.repo_name
         id_, params = build_data(
             self.apikey, 'comment_commit', repoid=repo_name,
             commit_id=commit_id, message='message', status_change=None)
         response = api_call(self.app, params)
 
         expected_err = expected_err[backend.alias]
         expected_err = expected_err.format(
             repo=backend.repo.scm_instance(), commit=commit_id)
         assert_error(id_, expected_err, given=response.body)
 
     @pytest.mark.parametrize("status_change, message, commit_id", [
         (None, 'Hallo', 'tip'),
         (ChangesetStatus.STATUS_APPROVED, 'Approved', 'tip'),
         (ChangesetStatus.STATUS_REJECTED, 'Rejected', 'tip'),
     ])
     def test_api_comment_commit(
             self, backend, status_change, message, commit_id,
             no_notifications):
 
-        commit_id = backend.repo.scm_instance().get_changeset(commit_id).raw_id
+        commit_id = backend.repo.scm_instance().get_commit(commit_id).raw_id
 
         id_, params = build_data(
             self.apikey, 'comment_commit', repoid=backend.repo_name,
             commit_id=commit_id, message=message, status=status_change)
         response = api_call(self.app, params)
         repo = backend.repo.scm_instance()
         expected = {
             'msg': 'Commented on commit `%s` for repository `%s`' % (
-                repo.get_changeset().raw_id, backend.repo_name),
+                repo.get_commit().raw_id, backend.repo_name),
             'status_change': status_change,
             'success': True
         }
         assert_ok(id_, expected, given=response.body)

rhodecode/apps/repository/views/repo_strip.py

@@ -1,113 +1,113 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2017-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import logging
 from pyramid.view import view_config
 
 from rhodecode.apps._base import RepoAppView
 from rhodecode.lib import audit_logger
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import (
     LoginRequired, HasRepoPermissionAnyDecorator, CSRFRequired)
 from rhodecode.lib.ext_json import json
 
 log = logging.getLogger(__name__)
 
 
 class StripView(RepoAppView):
     def load_default_context(self):
         c = self._get_local_tmpl_context()
 
 
         return c
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @view_config(
         route_name='edit_repo_strip', request_method='GET',
         renderer='rhodecode:templates/admin/repos/repo_edit.mako')
     def strip(self):
         c = self.load_default_context()
         c.active = 'strip'
         c.strip_limit = 10
 
         return self._get_template_context(c)
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='strip_check', request_method='POST',
         renderer='json', xhr=True)
     def strip_check(self):
         from rhodecode.lib.vcs.backends.base import EmptyCommit
         data = {}
         rp = self.request.POST
         for i in range(1, 11):
             chset = 'changeset_id-%d' % (i,)
             check = rp.get(chset)
 
             if check:
-                data[i] = self.db_repo.get_changeset(rp[chset])
+                data[i] = self.db_repo.get_commit(rp[chset])
                 if isinstance(data[i], EmptyCommit):
                     data[i] = {'rev': None, 'commit': h.escape(rp[chset])}
                 else:
                     data[i] = {'rev': data[i].raw_id, 'branch': data[i].branch,
                                'author': h.escape(data[i].author),
                                'comment': h.escape(data[i].message)}
             else:
                 break
         return data
 
     @LoginRequired()
     @HasRepoPermissionAnyDecorator('repository.admin')
     @CSRFRequired()
     @view_config(
         route_name='strip_execute', request_method='POST',
         renderer='json', xhr=True)
     def strip_execute(self):
         from rhodecode.model.scm import ScmModel
 
         c = self.load_default_context()
         user = self._rhodecode_user
         rp = self.request.POST
         data = {}
         for idx in rp:
             commit = json.loads(rp[idx])
             # If someone put two times the same branch
             if commit['branch'] in data.keys():
                 continue
             try:
                 ScmModel().strip(
                     repo=self.db_repo,
                     commit_id=commit['rev'], branch=commit['branch'])
                 log.info('Stripped commit %s from repo `%s` by %s',
                          commit['rev'], self.db_repo_name, user)
                 data[commit['rev']] = True
 
                 audit_logger.store_web(
                     'repo.commit.strip', action_data={'commit_id': commit['rev']},
                     repo=self.db_repo, user=self._rhodecode_user, commit=True)
 
             except Exception as e:
                 data[commit['rev']] = False
                 log.debug('Stripped commit %s from repo `%s` failed by %s, exeption %s',
                           commit['rev'], self.db_repo_name, user, e.message)
         return data

rhodecode/events/repo.py

@@ -1,356 +1,356 b''
 # Copyright (C) 2016-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import collections
 import logging
 import datetime
 
 from rhodecode.translation import lazy_ugettext
 from rhodecode.model.db import User, Repository, Session
 from rhodecode.events.base import RhodeCodeIntegrationEvent
 from rhodecode.lib.vcs.exceptions import CommitDoesNotExistError
 
 log = logging.getLogger(__name__)
 
 
 def _commits_as_dict(event, commit_ids, repos):
     """
     Helper function to serialize commit_ids
 
     :param event: class calling this method
     :param commit_ids: commits to get
     :param repos: list of repos to check
     """
     from rhodecode.lib.utils2 import extract_mentioned_users
     from rhodecode.lib.helpers import (
         urlify_commit_message, process_patterns, chop_at_smart)
     from rhodecode.model.repo import RepoModel
 
     if not repos:
         raise Exception('no repo defined')
 
     if not isinstance(repos, (tuple, list)):
         repos = [repos]
 
     if not commit_ids:
         return []
 
     needed_commits = list(commit_ids)
 
     commits = []
     reviewers = []
     for repo in repos:
         if not needed_commits:
             return commits  # return early if we have the commits we need
 
         vcs_repo = repo.scm_instance(cache=False)
 
         try:
             # use copy of needed_commits since we modify it while iterating
             for commit_id in list(needed_commits):
                 if commit_id.startswith('tag=>'):
                     raw_id = commit_id[5:]
                     cs_data = {
                         'raw_id': commit_id, 'short_id': commit_id,
                         'branch': None,
                         'git_ref_change': 'tag_add',
                         'message': 'Added new tag {}'.format(raw_id),
                         'author': event.actor.full_contact,
                         'date': datetime.datetime.now(),
                         'refs': {
                             'branches': [],
                             'bookmarks': [],
                             'tags': []
                         }
                     }
                     commits.append(cs_data)
 
                 elif commit_id.startswith('delete_branch=>'):
                     raw_id = commit_id[15:]
                     cs_data = {
                         'raw_id': commit_id, 'short_id': commit_id,
                         'branch': None,
                         'git_ref_change': 'branch_delete',
                         'message': 'Deleted branch {}'.format(raw_id),
                         'author': event.actor.full_contact,
                         'date': datetime.datetime.now(),
                         'refs': {
                             'branches': [],
                             'bookmarks': [],
                             'tags': []
                         }
                     }
                     commits.append(cs_data)
 
                 else:
                     try:
-                        cs = vcs_repo.get_changeset(commit_id)
+                        cs = vcs_repo.get_commit(commit_id)
                     except CommitDoesNotExistError:
                         continue  # maybe its in next repo
 
                     cs_data = cs.__json__()
                     cs_data['refs'] = cs._get_refs()
 
                 cs_data['mentions'] = extract_mentioned_users(cs_data['message'])
                 cs_data['reviewers'] = reviewers
                 cs_data['url'] = RepoModel().get_commit_url(
                     repo, cs_data['raw_id'], request=event.request)
                 cs_data['permalink_url'] = RepoModel().get_commit_url(
                     repo, cs_data['raw_id'], request=event.request,
                     permalink=True)
                 urlified_message, issues_data = process_patterns(
                     cs_data['message'], repo.repo_name)
                 cs_data['issues'] = issues_data
                 cs_data['message_html'] = urlify_commit_message(
                     cs_data['message'], repo.repo_name)
                 cs_data['message_html_title'] = chop_at_smart(
                     cs_data['message'], '\n', suffix_if_chopped='...')
                 commits.append(cs_data)
 
                 needed_commits.remove(commit_id)
 
         except Exception:
             log.exception('Failed to extract commits data')
             # we don't send any commits when crash happens, only full list
             # matters we short circuit then.
             return []
 
     missing_commits = set(commit_ids) - set(c['raw_id'] for c in commits)
     if missing_commits:
         log.error('Inconsistent repository state. '
                   'Missing commits: %s', ', '.join(missing_commits))
 
     return commits
 
 
 def _issues_as_dict(commits):
     """ Helper function to serialize issues from commits """
     issues = {}
     for commit in commits:
         for issue in commit['issues']:
             issues[issue['id']] = issue
     return issues
 
 
 class RepoEvent(RhodeCodeIntegrationEvent):
     """
     Base class for events acting on a repository.
 
     :param repo: a :class:`Repository` instance
     """
 
     def __init__(self, repo):
         super(RepoEvent, self).__init__()
         self.repo = repo
 
     def as_dict(self):
         from rhodecode.model.repo import RepoModel
         data = super(RepoEvent, self).as_dict()
 
         extra_fields = collections.OrderedDict()
         for field in self.repo.extra_fields:
             extra_fields[field.field_key] = field.field_value
 
         data.update({
             'repo': {
                 'repo_id': self.repo.repo_id,
                 'repo_name': self.repo.repo_name,
                 'repo_type': self.repo.repo_type,
                 'url': RepoModel().get_url(
                     self.repo, request=self.request),
                 'permalink_url': RepoModel().get_url(
                     self.repo, request=self.request, permalink=True),
                 'extra_fields': extra_fields
             }
         })
         return data
 
 
 class RepoPreCreateEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` before a repo is
     created.
     """
     name = 'repo-pre-create'
     display_name = lazy_ugettext('repository pre create')
 
 
 class RepoCreateEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
     name = 'repo-create'
     display_name = lazy_ugettext('repository created')
 
 
 class RepoPreDeleteEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
     name = 'repo-pre-delete'
     display_name = lazy_ugettext('repository pre delete')
 
 
 class RepoDeleteEvent(RepoEvent):
     """
     An instance of this class is emitted as an :term:`event` whenever a repo is
     created.
     """
     name = 'repo-delete'
     display_name = lazy_ugettext('repository deleted')
 
 
 class RepoVCSEvent(RepoEvent):
     """
     Base class for events triggered by the VCS
     """
     def __init__(self, repo_name, extras):
         self.repo = Repository.get_by_repo_name(repo_name)
         if not self.repo:
             raise Exception('repo by this name %s does not exist' % repo_name)
         self.extras = extras
         super(RepoVCSEvent, self).__init__(self.repo)
 
     @property
     def actor(self):
         if self.extras.get('username'):
             return User.get_by_username(self.extras['username'])
 
     @property
     def actor_ip(self):
         if self.extras.get('ip'):
             return self.extras['ip']
 
     @property
     def server_url(self):
         if self.extras.get('server_url'):
             return self.extras['server_url']
 
     @property
     def request(self):
         return self.extras.get('request') or self.get_request()
 
 
 class RepoPrePullEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` before commits
     are pulled from a repo.
     """
     name = 'repo-pre-pull'
     display_name = lazy_ugettext('repository pre pull')
 
 
 class RepoPullEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` after commits
     are pulled from a repo.
     """
     name = 'repo-pull'
     display_name = lazy_ugettext('repository pull')
 
 
 class RepoPrePushEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` before commits
     are pushed to a repo.
     """
     name = 'repo-pre-push'
     display_name = lazy_ugettext('repository pre push')
 
 
 class RepoPushEvent(RepoVCSEvent):
     """
     An instance of this class is emitted as an :term:`event` after commits
     are pushed to a repo.
 
     :param extras: (optional) dict of data from proxied VCS actions
     """
     name = 'repo-push'
     display_name = lazy_ugettext('repository push')
 
     def __init__(self, repo_name, pushed_commit_ids, extras):
         super(RepoPushEvent, self).__init__(repo_name, extras)
         self.pushed_commit_ids = pushed_commit_ids
         self.new_refs = extras.new_refs
 
     def as_dict(self):
         data = super(RepoPushEvent, self).as_dict()
 
         def branch_url(branch_name):
             return '{}/changelog?branch={}'.format(
                 data['repo']['url'], branch_name)
 
         def tag_url(tag_name):
             return '{}/files/{}/'.format(
                 data['repo']['url'], tag_name)
 
         commits = _commits_as_dict(
             self, commit_ids=self.pushed_commit_ids, repos=[self.repo])
 
         last_branch = None
         for commit in reversed(commits):
             commit['branch'] = commit['branch'] or last_branch
             last_branch = commit['branch']
         issues = _issues_as_dict(commits)
 
         branches = set()
         tags = set()
         for commit in commits:
             if commit['refs']['tags']:
                 for tag in commit['refs']['tags']:
                     tags.add(tag)
             if commit['branch']:
                 branches.add(commit['branch'])
 
         # maybe we have branches in new_refs ?
         try:
             branches = branches.union(set(self.new_refs['branches']))
         except Exception:
             pass
 
         branches = [
             {
                 'name': branch,
                 'url': branch_url(branch)
             }
             for branch in branches
         ]
 
         # maybe we have branches in new_refs ?
         try:
             tags = tags.union(set(self.new_refs['tags']))
         except Exception:
             pass
 
         tags = [
             {
                 'name': tag,
                 'url': tag_url(tag)
             }
             for tag in tags
         ]
 
         data['push'] = {
             'commits': commits,
             'issues': issues,
             'branches': branches,
             'tags': tags,
         }
         return data

rhodecode/tests/models/test_scm.py

@@ -1,196 +1,196 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import os
 import stat
 import sys
 
 import pytest
 from mock import Mock, patch, DEFAULT
 
 import rhodecode
 from rhodecode.model import db, scm
 from rhodecode.tests import no_newline_id_generator
 
 
 def test_scm_instance_config(backend):
     repo = backend.create_repo()
     with patch.multiple('rhodecode.model.db.Repository',
                         _get_instance=DEFAULT,
                         _get_instance_cached=DEFAULT) as mocks:
         repo.scm_instance()
         mocks['_get_instance'].assert_called_with(
             config=None, cache=False)
 
         config = {'some': 'value'}
         repo.scm_instance(config=config)
         mocks['_get_instance'].assert_called_with(
             config=config, cache=False)
 
         with patch.dict(rhodecode.CONFIG, {'vcs_full_cache': 'true'}):
             repo.scm_instance(config=config)
             mocks['_get_instance_cached'].assert_called()
 
 
 def test__get_instance_config(backend):
     repo = backend.create_repo()
     vcs_class = Mock()
     with patch.multiple('rhodecode.lib.vcs.backends',
                         get_scm=DEFAULT,
                         get_backend=DEFAULT) as mocks:
         mocks['get_scm'].return_value = backend.alias
         mocks['get_backend'].return_value = vcs_class
         with patch('rhodecode.model.db.Repository._config') as config_mock:
             repo._get_instance()
             vcs_class.assert_called_with(
                 repo_path=repo.repo_full_path, config=config_mock,
                 create=False, with_wire={'cache': True})
 
         new_config = {'override': 'old_config'}
         repo._get_instance(config=new_config)
         vcs_class.assert_called_with(
             repo_path=repo.repo_full_path, config=new_config, create=False,
             with_wire={'cache': True})
 
 
 def test_mark_for_invalidation_config(backend):
     repo = backend.create_repo()
     with patch('rhodecode.model.db.Repository.update_commit_cache') as _mock:
         scm.ScmModel().mark_for_invalidation(repo.repo_name)
         _, kwargs = _mock.call_args
         assert kwargs['config'].__dict__ == repo._config.__dict__
 
 
 def test_mark_for_invalidation_with_delete_updates_last_commit(backend):
     commits = [{'message': 'A'}, {'message': 'B'}]
     repo = backend.create_repo(commits=commits)
     scm.ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
     assert repo.changeset_cache['revision'] == 1
 
 
 def test_mark_for_invalidation_with_delete_updates_last_commit_empty(backend):
     repo = backend.create_repo()
     scm.ScmModel().mark_for_invalidation(repo.repo_name, delete=True)
     assert repo.changeset_cache['revision'] == -1
 
 
 def test_strip_with_multiple_heads(backend_hg):
     commits = [
         {'message': 'A'},
         {'message': 'a'},
         {'message': 'b'},
         {'message': 'B', 'parents': ['A']},
         {'message': 'a1'},
     ]
     repo = backend_hg.create_repo(commits=commits)
     commit_ids = backend_hg.commit_ids
 
     model = scm.ScmModel()
     model.strip(repo, commit_ids['b'], branch=None)
 
     vcs_repo = repo.scm_instance()
-    rest_commit_ids = [c.raw_id for c in vcs_repo.get_changesets()]
+    rest_commit_ids = [c.raw_id for c in vcs_repo.get_commits()]
     assert len(rest_commit_ids) == 4
     assert commit_ids['b'] not in rest_commit_ids
 
 
 def test_strip_with_single_heads(backend_hg):
     commits = [
         {'message': 'A'},
         {'message': 'a'},
         {'message': 'b'},
     ]
     repo = backend_hg.create_repo(commits=commits)
     commit_ids = backend_hg.commit_ids
 
     model = scm.ScmModel()
     model.strip(repo, commit_ids['b'], branch=None)
 
     vcs_repo = repo.scm_instance()
-    rest_commit_ids = [c.raw_id for c in vcs_repo.get_changesets()]
+    rest_commit_ids = [c.raw_id for c in vcs_repo.get_commits()]
     assert len(rest_commit_ids) == 2
     assert commit_ids['b'] not in rest_commit_ids
 
 
 def test_get_nodes_returns_unicode_flat(backend_random):
     repo = backend_random.repo
     directories, files = scm.ScmModel().get_nodes(
         repo.repo_name, repo.get_commit(commit_idx=0).raw_id,
         flat=True)
     assert_contains_only_unicode(directories)
     assert_contains_only_unicode(files)
 
 
 def test_get_nodes_returns_unicode_non_flat(backend_random):
     repo = backend_random.repo
     directories, files = scm.ScmModel().get_nodes(
         repo.repo_name, repo.get_commit(commit_idx=0).raw_id,
         flat=False)
     # johbo: Checking only the names for now, since that is the critical
     # part.
     assert_contains_only_unicode([d['name'] for d in directories])
     assert_contains_only_unicode([f['name'] for f in files])
 
 
 def test_get_nodes_max_file_bytes(backend_random):
     repo = backend_random.repo
     max_file_bytes = 10
     directories, files = scm.ScmModel().get_nodes(
         repo.repo_name, repo.get_commit(commit_idx=0).raw_id, content=True,
         extended_info=True, flat=False)
     assert any(file['content'] and len(file['content']) > max_file_bytes
                for file in files)
 
     directories, files = scm.ScmModel().get_nodes(
         repo.repo_name, repo.get_commit(commit_idx=0).raw_id, content=True,
         extended_info=True, flat=False, max_file_bytes=max_file_bytes)
     assert all(
         file['content'] is None if file['size'] > max_file_bytes else True
         for file in files)
 
 
 def assert_contains_only_unicode(structure):
     assert structure
     for value in structure:
         assert isinstance(value, unicode)
 
 
 @pytest.mark.backends("hg", "git")
 def test_get_non_unicode_reference(backend):
     model = scm.ScmModel()
     non_unicode_list = ["Adını".decode("cp1254")]
 
     def scm_instance():
         return Mock(
             branches=non_unicode_list, bookmarks=non_unicode_list,
             tags=non_unicode_list, alias=backend.alias)
 
     repo = Mock(__class__=db.Repository, scm_instance=scm_instance)
     choices, __ = model.get_repo_landing_revs(translator=lambda s: s, repo=repo)
     if backend.alias == 'hg':
         valid_choices = [
             'rev:tip', u'branch:Ad\xc4\xb1n\xc4\xb1',
             u'book:Ad\xc4\xb1n\xc4\xb1', u'tag:Ad\xc4\xb1n\xc4\xb1']
     else:
         valid_choices = [
             'rev:tip', u'branch:Ad\xc4\xb1n\xc4\xb1',
             u'tag:Ad\xc4\xb1n\xc4\xb1']
 
     assert choices == valid_choices