vcs-ops: store user_id inside the extras for vcs context operations.

- we'll use this one for bootstrap of async tasks.

rhodecode/apps/ssh_support/lib/backends/base.py

@@ -1,149 +1,150 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2017 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 sys
 import json
 import logging
 
 from rhodecode.lib.hooks_daemon import prepare_callback_daemon
 from rhodecode.lib.vcs.conf import settings as vcs_settings
 from rhodecode.model.scm import ScmModel
 
 log = logging.getLogger(__name__)
 
 
 class VcsServer(object):
     _path = None  # set executable path for hg/git/svn binary
     backend = None  # set in child classes
     tunnel = None  # subprocess handling tunnel
     write_perms = ['repository.admin', 'repository.write']
     read_perms = ['repository.read', 'repository.admin', 'repository.write']
 
     def __init__(self, user, user_permissions, config, env):
         self.user = user
         self.user_permissions = user_permissions
         self.config = config
         self.env = env
         self.stdin = sys.stdin
 
         self.repo_name = None
         self.repo_mode = None
         self.store = ''
         self.ini_path = ''
 
     def _invalidate_cache(self, repo_name):
         """
         Set's cache for this repository for invalidation on next access
 
         :param repo_name: full repo name, also a cache key
         """
         ScmModel().mark_for_invalidation(repo_name)
 
     def has_write_perm(self):
         permission = self.user_permissions.get(self.repo_name)
         if permission in ['repository.write', 'repository.admin']:
             return True
 
         return False
 
     def _check_permissions(self, action):
         permission = self.user_permissions.get(self.repo_name)
         log.debug(
             'permission for %s on %s are: %s',
             self.user, self.repo_name, permission)
 
         if action == 'pull':
             if permission in self.read_perms:
                 log.info(
                     'READ Permissions for User "%s" detected to repo "%s"!',
                     self.user, self.repo_name)
                 return 0
         else:
             if permission in self.write_perms:
                 log.info(
                     'WRITE+ Permissions for User "%s" detected to repo "%s"!',
                     self.user, self.repo_name)
                 return 0
 
         log.error('Cannot properly fetch or allow user %s permissions. '
                   'Return value is: %s, req action: %s',
                   self.user, permission, action)
         return -2
 
     def update_environment(self, action, extras=None):
 
         scm_data = {
             'ip': os.environ['SSH_CLIENT'].split()[0],
             'username': self.user.username,
+            'user_id': self.user.user_id,
             'action': action,
             'repository': self.repo_name,
             'scm': self.backend,
             'config': self.ini_path,
             'make_lock': None,
             'locked_by': [None, None],
             'server_url': None,
             'is_shadow_repo': False,
             'hooks_module': 'rhodecode.lib.hooks_daemon',
             'hooks': ['push', 'pull'],
             'SSH': True,
             'SSH_PERMISSIONS': self.user_permissions.get(self.repo_name)
         }
         if extras:
             scm_data.update(extras)
         os.putenv("RC_SCM_DATA", json.dumps(scm_data))
 
     def get_root_store(self):
         root_store = self.store
         if not root_store.endswith('/'):
             # always append trailing slash
             root_store = root_store + '/'
         return root_store
 
     def _handle_tunnel(self, extras):
         # pre-auth
         action = 'pull'
         exit_code = self._check_permissions(action)
         if exit_code:
             return exit_code, False
 
         req = self.env['request']
         server_url = req.host_url + req.script_name
         extras['server_url'] = server_url
 
         log.debug('Using %s binaries from path %s', self.backend, self._path)
         exit_code = self.tunnel.run(extras)
 
         return exit_code, action == "push"
 
     def run(self):
         extras = {}
 
         callback_daemon, extras = prepare_callback_daemon(
             extras, protocol=vcs_settings.HOOKS_PROTOCOL,
             use_direct_calls=False)
 
         with callback_daemon:
             try:
                 return self._handle_tunnel(extras)
             finally:
                 log.debug('Running cleanup with cache invalidation')
                 if self.repo_name:
                     self._invalidate_cache(self.repo_name)

rhodecode/apps/ssh_support/tests/test_server_git.py

@@ -1,145 +1,146 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2017 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 json
 import mock
 import pytest
 
 from rhodecode.apps.ssh_support.lib.backends.git import GitServer
 from rhodecode.apps.ssh_support.tests.conftest import dummy_env, dummy_user
 
 
 class GitServerCreator(object):
     root = '/tmp/repo/path/'
     git_path = '/usr/local/bin/git'
     config_data = {
         'app:main': {
             'ssh.executable.git': git_path,
             'vcs.hooks.protocol': 'http',
         }
     }
     repo_name = 'test_git'
     repo_mode = 'receive-pack'
     user = dummy_user()
 
     def __init__(self):
         def config_get(part, key):
             return self.config_data.get(part, {}).get(key)
         self.config_mock = mock.Mock()
         self.config_mock.get = mock.Mock(side_effect=config_get)
 
     def create(self, **kwargs):
         parameters = {
             'store': self.root,
             'ini_path': '',
             'user': self.user,
             'repo_name': self.repo_name,
             'repo_mode': self.repo_mode,
             'user_permissions': {
                 self.repo_name: 'repository.admin'
             },
             'config': self.config_mock,
             'env': dummy_env()
         }
         parameters.update(kwargs)
         server = GitServer(**parameters)
         return server
 
 
 @pytest.fixture
 def git_server(app):
     return GitServerCreator()
 
 
 class TestGitServer(object):
 
     def test_command(self, git_server):
         server = git_server.create()
         expected_command = (
             'cd {root}; {git_path} {repo_mode} \'{root}{repo_name}\''.format(
                 root=git_server.root, git_path=git_server.git_path,
                 repo_mode=git_server.repo_mode, repo_name=git_server.repo_name)
         )
         assert expected_command == server.tunnel.command()
 
     @pytest.mark.parametrize('permissions, action, code', [
         ({}, 'pull', -2),
         ({'test_git': 'repository.read'}, 'pull', 0),
         ({'test_git': 'repository.read'}, 'push', -2),
         ({'test_git': 'repository.write'}, 'push', 0),
         ({'test_git': 'repository.admin'}, 'push', 0),
 
     ])
     def test_permission_checks(self, git_server, permissions, action, code):
         server = git_server.create(user_permissions=permissions)
         result = server._check_permissions(action)
         assert result is code
 
     @pytest.mark.parametrize('permissions, value', [
         ({}, False),
         ({'test_git': 'repository.read'}, False),
         ({'test_git': 'repository.write'}, True),
         ({'test_git': 'repository.admin'}, True),
 
     ])
     def test_has_write_permissions(self, git_server, permissions, value):
         server = git_server.create(user_permissions=permissions)
         result = server.has_write_perm()
         assert result is value
 
     def test_run_returns_executes_command(self, git_server):
         server = git_server.create()
         from rhodecode.apps.ssh_support.lib.backends.git import GitTunnelWrapper
         with mock.patch.object(GitTunnelWrapper, 'create_hooks_env') as _patch:
             _patch.return_value = 0
             with mock.patch.object(GitTunnelWrapper, 'command', return_value='date'):
                 exit_code = server.run()
 
         assert exit_code == (0, False)
 
     @pytest.mark.parametrize(
         'repo_mode, action', [
             ['receive-pack', 'push'],
             ['upload-pack', 'pull']
         ])
     def test_update_environment(self, git_server, repo_mode, action):
         server = git_server.create(repo_mode=repo_mode)
         with mock.patch('os.environ', {'SSH_CLIENT': '10.10.10.10 b'}):
             with mock.patch('os.putenv') as putenv_mock:
                 server.update_environment(action)
 
         expected_data = {
             'username': git_server.user.username,
+            'user_id': git_server.user.user_id,
             'scm': 'git',
             'repository': git_server.repo_name,
             'make_lock': None,
             'action': action,
             'ip': '10.10.10.10',
             'locked_by': [None, None],
             'config': '',
             'server_url': None,
             'hooks': ['push', 'pull'],
             'is_shadow_repo': False,
             'hooks_module': 'rhodecode.lib.hooks_daemon',
             'SSH': True,
             'SSH_PERMISSIONS': 'repository.admin',
         }
         args, kwargs = putenv_mock.call_args
         assert json.loads(args[1]) == expected_data

rhodecode/lib/base.py

@@ -1,541 +1,542 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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/
 
 """
 The base Controller API
 Provides the BaseController class for subclassing. And usage in different
 controllers
 """
 
 import logging
 import socket
 
 import markupsafe
 import ipaddress
 
 from paste.auth.basic import AuthBasicAuthenticator
 from paste.httpexceptions import HTTPUnauthorized, HTTPForbidden, get_exception
 from paste.httpheaders import WWW_AUTHENTICATE, AUTHORIZATION
 
 import rhodecode
 from rhodecode.authentication.base import VCS_TYPE
 from rhodecode.lib import auth, utils2
 from rhodecode.lib import helpers as h
 from rhodecode.lib.auth import AuthUser, CookieStoreWrapper
 from rhodecode.lib.exceptions import UserCreationError
 from rhodecode.lib.utils import (password_changed, get_enabled_hook_classes)
 from rhodecode.lib.utils2 import (
     str2bool, safe_unicode, AttributeDict, safe_int, md5, aslist, safe_str)
 from rhodecode.model.db import Repository, User, ChangesetComment
 from rhodecode.model.notification import NotificationModel
 from rhodecode.model.settings import VcsSettingsModel, SettingsModel
 
 log = logging.getLogger(__name__)
 
 
 def _filter_proxy(ip):
     """
     Passed in IP addresses in HEADERS can be in a special format of multiple
     ips. Those comma separated IPs are passed from various proxies in the
     chain of request processing. The left-most being the original client.
     We only care about the first IP which came from the org. client.
 
     :param ip: ip string from headers
     """
     if ',' in ip:
         _ips = ip.split(',')
         _first_ip = _ips[0].strip()
         log.debug('Got multiple IPs %s, using %s', ','.join(_ips), _first_ip)
         return _first_ip
     return ip
 
 
 def _filter_port(ip):
     """
     Removes a port from ip, there are 4 main cases to handle here.
     - ipv4 eg. 127.0.0.1
     - ipv6 eg. ::1
     - ipv4+port eg. 127.0.0.1:8080
     - ipv6+port eg. [::1]:8080
 
     :param ip:
     """
     def is_ipv6(ip_addr):
         if hasattr(socket, 'inet_pton'):
             try:
                 socket.inet_pton(socket.AF_INET6, ip_addr)
             except socket.error:
                 return False
         else:
             # fallback to ipaddress
             try:
                 ipaddress.IPv6Address(safe_unicode(ip_addr))
             except Exception:
                 return False
         return True
 
     if ':' not in ip:  # must be ipv4 pure ip
         return ip
 
     if '[' in ip and ']' in ip:  # ipv6 with port
         return ip.split(']')[0][1:].lower()
 
     # must be ipv6 or ipv4 with port
     if is_ipv6(ip):
         return ip
     else:
         ip, _port = ip.split(':')[:2]  # means ipv4+port
         return ip
 
 
 def get_ip_addr(environ):
     proxy_key = 'HTTP_X_REAL_IP'
     proxy_key2 = 'HTTP_X_FORWARDED_FOR'
     def_key = 'REMOTE_ADDR'
     _filters = lambda x: _filter_port(_filter_proxy(x))
 
     ip = environ.get(proxy_key)
     if ip:
         return _filters(ip)
 
     ip = environ.get(proxy_key2)
     if ip:
         return _filters(ip)
 
     ip = environ.get(def_key, '0.0.0.0')
     return _filters(ip)
 
 
 def get_server_ip_addr(environ, log_errors=True):
     hostname = environ.get('SERVER_NAME')
     try:
         return socket.gethostbyname(hostname)
     except Exception as e:
         if log_errors:
             # in some cases this lookup is not possible, and we don't want to
             # make it an exception in logs
             log.exception('Could not retrieve server ip address: %s', e)
         return hostname
 
 
 def get_server_port(environ):
     return environ.get('SERVER_PORT')
 
 
 def get_access_path(environ):
     path = environ.get('PATH_INFO')
     org_req = environ.get('pylons.original_request')
     if org_req:
         path = org_req.environ.get('PATH_INFO')
     return path
 
 
 def get_user_agent(environ):
     return environ.get('HTTP_USER_AGENT')
 
 
 def vcs_operation_context(
         environ, repo_name, username, action, scm, check_locking=True,
         is_shadow_repo=False):
     """
     Generate the context for a vcs operation, e.g. push or pull.
 
     This context is passed over the layers so that hooks triggered by the
     vcs operation know details like the user, the user's IP address etc.
 
     :param check_locking: Allows to switch of the computation of the locking
         data. This serves mainly the need of the simplevcs middleware to be
         able to disable this for certain operations.
 
     """
     # Tri-state value: False: unlock, None: nothing, True: lock
     make_lock = None
     locked_by = [None, None, None]
     is_anonymous = username == User.DEFAULT_USER
+    user = User.get_by_username(username)
     if not is_anonymous and check_locking:
         log.debug('Checking locking on repository "%s"', repo_name)
-        user = User.get_by_username(username)
         repo = Repository.get_by_repo_name(repo_name)
         make_lock, __, locked_by = repo.get_locking_state(
             action, user.user_id)
-
+    user_id = user.user_id
     settings_model = VcsSettingsModel(repo=repo_name)
     ui_settings = settings_model.get_ui_settings()
 
     extras = {
         'ip': get_ip_addr(environ),
         'username': username,
+        'user_id': user_id,
         'action': action,
         'repository': repo_name,
         'scm': scm,
         'config': rhodecode.CONFIG['__file__'],
         'make_lock': make_lock,
         'locked_by': locked_by,
         'server_url': utils2.get_server_url(environ),
         'user_agent': get_user_agent(environ),
         'hooks': get_enabled_hook_classes(ui_settings),
         'is_shadow_repo': is_shadow_repo,
     }
     return extras
 
 
 class BasicAuth(AuthBasicAuthenticator):
 
     def __init__(self, realm, authfunc, registry, auth_http_code=None,
                  initial_call_detection=False, acl_repo_name=None):
         self.realm = realm
         self.initial_call = initial_call_detection
         self.authfunc = authfunc
         self.registry = registry
         self.acl_repo_name = acl_repo_name
         self._rc_auth_http_code = auth_http_code
 
     def _get_response_from_code(self, http_code):
         try:
             return get_exception(safe_int(http_code))
         except Exception:
             log.exception('Failed to fetch response for code %s' % http_code)
             return HTTPForbidden
 
     def get_rc_realm(self):
         return safe_str(self.registry.rhodecode_settings.get('rhodecode_realm'))
 
     def build_authentication(self):
         head = WWW_AUTHENTICATE.tuples('Basic realm="%s"' % self.realm)
         if self._rc_auth_http_code and not self.initial_call:
             # return alternative HTTP code if alternative http return code
             # is specified in RhodeCode config, but ONLY if it's not the
             # FIRST call
             custom_response_klass = self._get_response_from_code(
                 self._rc_auth_http_code)
             return custom_response_klass(headers=head)
         return HTTPUnauthorized(headers=head)
 
     def authenticate(self, environ):
         authorization = AUTHORIZATION(environ)
         if not authorization:
             return self.build_authentication()
         (authmeth, auth) = authorization.split(' ', 1)
         if 'basic' != authmeth.lower():
             return self.build_authentication()
         auth = auth.strip().decode('base64')
         _parts = auth.split(':', 1)
         if len(_parts) == 2:
             username, password = _parts
             auth_data = self.authfunc(
                     username, password, environ, VCS_TYPE,
                     registry=self.registry, acl_repo_name=self.acl_repo_name)
             if auth_data:
                 return {'username': username, 'auth_data': auth_data}
             if username and password:
                 # we mark that we actually executed authentication once, at
                 # that point we can use the alternative auth code
                 self.initial_call = False
 
         return self.build_authentication()
 
     __call__ = authenticate
 
 
 def calculate_version_hash(config):
     return md5(
         config.get('beaker.session.secret', '') +
         rhodecode.__version__)[:8]
 
 
 def get_current_lang(request):
     # NOTE(marcink): remove after pyramid move
     try:
         return translation.get_lang()[0]
     except:
         pass
 
     return getattr(request, '_LOCALE_', request.locale_name)
 
 
 def attach_context_attributes(context, request, user_id):
     """
     Attach variables into template context called `c`.
     """
     config = request.registry.settings
 
 
     rc_config = SettingsModel().get_all_settings(cache=True)
 
     context.rhodecode_version = rhodecode.__version__
     context.rhodecode_edition = config.get('rhodecode.edition')
     # unique secret + version does not leak the version but keep consistency
     context.rhodecode_version_hash = calculate_version_hash(config)
 
     # Default language set for the incoming request
     context.language = get_current_lang(request)
 
     # Visual options
     context.visual = AttributeDict({})
 
     # DB stored Visual Items
     context.visual.show_public_icon = str2bool(
         rc_config.get('rhodecode_show_public_icon'))
     context.visual.show_private_icon = str2bool(
         rc_config.get('rhodecode_show_private_icon'))
     context.visual.stylify_metatags = str2bool(
         rc_config.get('rhodecode_stylify_metatags'))
     context.visual.dashboard_items = safe_int(
         rc_config.get('rhodecode_dashboard_items', 100))
     context.visual.admin_grid_items = safe_int(
         rc_config.get('rhodecode_admin_grid_items', 100))
     context.visual.repository_fields = str2bool(
         rc_config.get('rhodecode_repository_fields'))
     context.visual.show_version = str2bool(
         rc_config.get('rhodecode_show_version'))
     context.visual.use_gravatar = str2bool(
         rc_config.get('rhodecode_use_gravatar'))
     context.visual.gravatar_url = rc_config.get('rhodecode_gravatar_url')
     context.visual.default_renderer = rc_config.get(
         'rhodecode_markup_renderer', 'rst')
     context.visual.comment_types = ChangesetComment.COMMENT_TYPES
     context.visual.rhodecode_support_url = \
         rc_config.get('rhodecode_support_url') or h.route_url('rhodecode_support')
 
     context.visual.affected_files_cut_off = 60
 
     context.pre_code = rc_config.get('rhodecode_pre_code')
     context.post_code = rc_config.get('rhodecode_post_code')
     context.rhodecode_name = rc_config.get('rhodecode_title')
     context.default_encodings = aslist(config.get('default_encoding'), sep=',')
     # if we have specified default_encoding in the request, it has more
     # priority
     if request.GET.get('default_encoding'):
         context.default_encodings.insert(0, request.GET.get('default_encoding'))
     context.clone_uri_tmpl = rc_config.get('rhodecode_clone_uri_tmpl')
 
     # INI stored
     context.labs_active = str2bool(
         config.get('labs_settings_active', 'false'))
     context.visual.allow_repo_location_change = str2bool(
         config.get('allow_repo_location_change', True))
     context.visual.allow_custom_hooks_settings = str2bool(
         config.get('allow_custom_hooks_settings', True))
     context.debug_style = str2bool(config.get('debug_style', False))
 
     context.rhodecode_instanceid = config.get('instance_id')
 
     context.visual.cut_off_limit_diff = safe_int(
         config.get('cut_off_limit_diff'))
     context.visual.cut_off_limit_file = safe_int(
         config.get('cut_off_limit_file'))
 
     # AppEnlight
     context.appenlight_enabled = str2bool(config.get('appenlight', 'false'))
     context.appenlight_api_public_key = config.get(
         'appenlight.api_public_key', '')
     context.appenlight_server_url = config.get('appenlight.server_url', '')
 
     # JS template context
     context.template_context = {
         'repo_name': None,
         'repo_type': None,
         'repo_landing_commit': None,
         'rhodecode_user': {
             'username': None,
             'email': None,
             'notification_status': False
         },
         'visual': {
             'default_renderer': None
         },
         'commit_data': {
             'commit_id': None
         },
         'pull_request_data': {'pull_request_id': None},
         'timeago': {
             'refresh_time': 120 * 1000,
             'cutoff_limit': 1000 * 60 * 60 * 24 * 7
         },
         'pyramid_dispatch': {
 
         },
         'extra': {'plugins': {}}
     }
     # END CONFIG VARS
 
     diffmode = 'sideside'
     if request.GET.get('diffmode'):
         if request.GET['diffmode'] == 'unified':
             diffmode = 'unified'
     elif request.session.get('diffmode'):
         diffmode = request.session['diffmode']
 
     context.diffmode = diffmode
 
     if request.session.get('diffmode') != diffmode:
         request.session['diffmode'] = diffmode
 
     context.csrf_token = auth.get_csrf_token(session=request.session)
     context.backends = rhodecode.BACKENDS.keys()
     context.backends.sort()
     context.unread_notifications = NotificationModel().get_unread_cnt_for_user(user_id)
 
     # web case
     if hasattr(request, 'user'):
         context.auth_user = request.user
         context.rhodecode_user = request.user
 
     # api case
     if hasattr(request, 'rpc_user'):
         context.auth_user = request.rpc_user
         context.rhodecode_user = request.rpc_user
 
     # attach the whole call context to the request
     request.call_context = context
 
 
 def get_auth_user(request):
     environ = request.environ
     session = request.session
 
     ip_addr = get_ip_addr(environ)
     # make sure that we update permissions each time we call controller
     _auth_token = (request.GET.get('auth_token', '') or
                    request.GET.get('api_key', ''))
 
     if _auth_token:
         # when using API_KEY we assume user exists, and
         # doesn't need auth based on cookies.
         auth_user = AuthUser(api_key=_auth_token, ip_addr=ip_addr)
         authenticated = False
     else:
         cookie_store = CookieStoreWrapper(session.get('rhodecode_user'))
         try:
             auth_user = AuthUser(user_id=cookie_store.get('user_id', None),
                                  ip_addr=ip_addr)
         except UserCreationError as e:
             h.flash(e, 'error')
             # container auth or other auth functions that create users
             # on the fly can throw this exception signaling that there's
             # issue with user creation, explanation should be provided
             # in Exception itself. We then create a simple blank
             # AuthUser
             auth_user = AuthUser(ip_addr=ip_addr)
 
         # in case someone changes a password for user it triggers session
         # flush and forces a re-login
         if password_changed(auth_user, session):
             session.invalidate()
             cookie_store = CookieStoreWrapper(session.get('rhodecode_user'))
             auth_user = AuthUser(ip_addr=ip_addr)
 
         authenticated = cookie_store.get('is_authenticated')
 
     if not auth_user.is_authenticated and auth_user.is_user_object:
         # user is not authenticated and not empty
         auth_user.set_authenticated(authenticated)
 
     return auth_user
 
 
 def h_filter(s):
     """
     Custom filter for Mako templates. Mako by standard uses `markupsafe.escape`
     we wrap this with additional functionality that converts None to empty
     strings
     """
     if s is None:
         return markupsafe.Markup()
     return markupsafe.escape(s)
 
 
 def add_events_routes(config):
     """
     Adds routing that can be used in events. Because some events are triggered
     outside of pyramid context, we need to bootstrap request with some
     routing registered
     """
 
     from rhodecode.apps._base import ADMIN_PREFIX
 
     config.add_route(name='home', pattern='/')
 
     config.add_route(name='login', pattern=ADMIN_PREFIX + '/login')
     config.add_route(name='logout', pattern=ADMIN_PREFIX + '/logout')
     config.add_route(name='repo_summary', pattern='/{repo_name}')
     config.add_route(name='repo_summary_explicit', pattern='/{repo_name}/summary')
     config.add_route(name='repo_group_home', pattern='/{repo_group_name}')
 
     config.add_route(name='pullrequest_show',
                      pattern='/{repo_name}/pull-request/{pull_request_id}')
     config.add_route(name='pull_requests_global',
                      pattern='/pull-request/{pull_request_id}')
     config.add_route(name='repo_commit',
                      pattern='/{repo_name}/changeset/{commit_id}')
 
     config.add_route(name='repo_files',
                      pattern='/{repo_name}/files/{commit_id}/{f_path}')
 
 
 def bootstrap_config(request):
     import pyramid.testing
     registry = pyramid.testing.Registry('RcTestRegistry')
 
     config = pyramid.testing.setUp(registry=registry, request=request)
 
     # allow pyramid lookup in testing
     config.include('pyramid_mako')
     config.include('pyramid_beaker')
     config.include('rhodecode.lib.caches')
 
     add_events_routes(config)
 
     return config
 
 
 def bootstrap_request(**kwargs):
     import pyramid.testing
 
     class TestRequest(pyramid.testing.DummyRequest):
         application_url = kwargs.pop('application_url', 'http://example.com')
         host = kwargs.pop('host', 'example.com:80')
         domain = kwargs.pop('domain', 'example.com')
 
         def translate(self, msg):
             return msg
 
         def plularize(self, singular, plural, n):
             return singular
 
         def get_partial_renderer(self, tmpl_name):
 
             from rhodecode.lib.partial_renderer import get_partial_renderer
             return get_partial_renderer(request=self, tmpl_name=tmpl_name)
 
         _call_context = {}
         @property
         def call_context(self):
             return self._call_context
 
     class TestDummySession(pyramid.testing.DummySession):
         def save(*arg, **kw):
             pass
 
     request = TestRequest(**kwargs)
     request.session = TestDummySession()
 
     return request
 

rhodecode/tests/events/test_repo.py

@@ -1,120 +1,121 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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.tests.events.conftest import EventCatcher
 
 from rhodecode.lib import hooks_base, utils2
 from rhodecode.model.repo import RepoModel
 from rhodecode.events.repo import (
     RepoPrePullEvent, RepoPullEvent,
     RepoPrePushEvent, RepoPushEvent,
     RepoPreCreateEvent, RepoCreateEvent,
     RepoPreDeleteEvent, RepoDeleteEvent,
 )
 
 
 @pytest.fixture
 def scm_extras(user_regular, repo_stub):
     extras = utils2.AttributeDict({
         'ip': '127.0.0.1',
         'username': user_regular.username,
+        'user_id': user_regular.user_id,
         'action': '',
         'repository': repo_stub.repo_name,
         'scm': repo_stub.scm_instance().alias,
         'config': '',
         'server_url': 'http://example.com',
         'make_lock': None,
         'user-agent': 'some-client',
         'locked_by': [None],
         'commit_ids': ['a' * 40] * 3,
         'is_shadow_repo': False,
     })
     return extras
 
 
 # TODO: dan: make the serialization tests complete json comparisons
 @pytest.mark.parametrize('EventClass', [
     RepoPreCreateEvent, RepoCreateEvent,
     RepoPreDeleteEvent, RepoDeleteEvent,
 ])
 def test_repo_events_serialized(config_stub, repo_stub, EventClass):
     event = EventClass(repo_stub)
     data = event.as_dict()
     assert data['name'] == EventClass.name
     assert data['repo']['repo_name'] == repo_stub.repo_name
     assert data['repo']['url']
     assert data['repo']['permalink_url']
 
 
 @pytest.mark.parametrize('EventClass', [
     RepoPrePullEvent, RepoPullEvent, RepoPrePushEvent
 ])
 def test_vcs_repo_events_serialize(config_stub, repo_stub, scm_extras, EventClass):
     event = EventClass(repo_name=repo_stub.repo_name, extras=scm_extras)
     data = event.as_dict()
     assert data['name'] == EventClass.name
     assert data['repo']['repo_name'] == repo_stub.repo_name
     assert data['repo']['url']
     assert data['repo']['permalink_url']
 
 
 @pytest.mark.parametrize('EventClass', [RepoPushEvent])
 def test_vcs_repo_push_event_serialize(config_stub, repo_stub, scm_extras, EventClass):
     event = EventClass(repo_name=repo_stub.repo_name,
                        pushed_commit_ids=scm_extras['commit_ids'],
                        extras=scm_extras)
     data = event.as_dict()
     assert data['name'] == EventClass.name
     assert data['repo']['repo_name'] == repo_stub.repo_name
     assert data['repo']['url']
     assert data['repo']['permalink_url']
 
 
 def test_create_delete_repo_fires_events(backend):
     with EventCatcher() as event_catcher:
         repo = backend.create_repo()
     assert event_catcher.events_types == [RepoPreCreateEvent, RepoCreateEvent]
 
     with EventCatcher() as event_catcher:
         RepoModel().delete(repo)
     assert event_catcher.events_types == [RepoPreDeleteEvent, RepoDeleteEvent]
 
 
 def test_pull_fires_events(scm_extras):
     with EventCatcher() as event_catcher:
         hooks_base.pre_push(scm_extras)
     assert event_catcher.events_types == [RepoPrePushEvent]
 
     with EventCatcher() as event_catcher:
         hooks_base.post_push(scm_extras)
     assert event_catcher.events_types == [RepoPushEvent]
 
 
 def test_push_fires_events(scm_extras):
     with EventCatcher() as event_catcher:
         hooks_base.pre_pull(scm_extras)
     assert event_catcher.events_types == [RepoPrePullEvent]
 
     with EventCatcher() as event_catcher:
         hooks_base.post_pull(scm_extras)
     assert event_catcher.events_types == [RepoPullEvent]
 

rhodecode/tests/integrations/conftest.py

@@ -1,52 +1,53 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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 import events
 
 
 @pytest.fixture
 def repo_push_event(backend, user_regular):
     commits = [
         {'message': 'ancestor commit fixes #15'},
         {'message': 'quick fixes'},
         {'message': 'change that fixes #41, #2'},
         {'message': 'this is because 5b23c3532 broke stuff'},
         {'message': 'last commit'},
     ]
     commit_ids = backend.create_master_repo(commits).values()
     repo = backend.create_repo()
     scm_extras = {
         'ip': '127.0.0.1',
         'username': user_regular.username,
+        'user_id': user_regular.user_id,
         'action': '',
         'repository': repo.repo_name,
         'scm': repo.scm_instance().alias,
         'config': '',
         'server_url': 'http://example.com',
         'make_lock': None,
         'locked_by': [None],
         'commit_ids': commit_ids,
     }
 
     return events.RepoPushEvent(repo_name=repo.repo_name,
                                 pushed_commit_ids=commit_ids,
                                 extras=scm_extras)

rhodecode/tests/lib/test_base.py

@@ -1,94 +1,96 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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 mock import Mock, patch
 
 from rhodecode.lib import base
 from rhodecode.model import db
 
 
 @pytest.mark.parametrize('result_key, expected_value', [
     ('username', 'stub_username'),
     ('action', 'stub_action'),
     ('repository', 'stub_repo_name'),
     ('scm', 'stub_scm'),
     ('hooks', ['stub_hook']),
     ('config', 'stub_ini_filename'),
     ('ip', '1.2.3.4'),
     ('server_url', 'https://example.com'),
     ('user_agent', 'client-text-v1.1'),
     # TODO: johbo: Commpare locking parameters with `_get_rc_scm_extras`
     # in hooks_utils.
     ('make_lock', None),
     ('locked_by', [None, None, None]),
 ])
 def test_vcs_operation_context_parameters(result_key, expected_value):
     result = call_vcs_operation_context()
     assert result[result_key] == expected_value
 
 
 @patch('rhodecode.model.db.User.get_by_username', Mock())
 @patch('rhodecode.model.db.Repository.get_by_repo_name')
 def test_vcs_operation_context_checks_locking(mock_get_by_repo_name):
     mock_get_locking_state = mock_get_by_repo_name().get_locking_state
     mock_get_locking_state.return_value = (None, None, [None, None, None])
     call_vcs_operation_context(check_locking=True)
     assert mock_get_locking_state.called
 
 
 @patch('rhodecode.model.db.Repository.get_locking_state')
 def test_vcs_operation_context_skips_locking_checks_if_anonymouse(
         mock_get_locking_state):
     call_vcs_operation_context(
         username=db.User.DEFAULT_USER, check_locking=True)
     assert not mock_get_locking_state.called
 
 
 @patch('rhodecode.model.db.Repository.get_locking_state')
 def test_vcs_operation_context_can_skip_locking_check(mock_get_locking_state):
     call_vcs_operation_context(check_locking=False)
     assert not mock_get_locking_state.called
 
 
 @patch.object(
     base, 'get_enabled_hook_classes', Mock(return_value=['stub_hook']))
 @patch('rhodecode.lib.utils2.get_server_url',
        Mock(return_value='https://example.com'))
[e-mail](db.User, 'get_by_username',
+       Mock(return_value=Mock(return_value=1)))
 def call_vcs_operation_context(**kwargs_override):
     kwargs = {
         'repo_name': 'stub_repo_name',
         'username': 'stub_username',
         'action': 'stub_action',
         'scm': 'stub_scm',
         'check_locking': False,
     }
     kwargs.update(kwargs_override)
     config_file_patch = patch.dict(
         'rhodecode.CONFIG', {'__file__': 'stub_ini_filename'})
     settings_patch = patch.object(base, 'VcsSettingsModel')
     with config_file_patch, settings_patch as settings_mock:
         result = base.vcs_operation_context(
             environ={'HTTP_USER_AGENT': 'client-text-v1.1',
                      'REMOTE_ADDR': '1.2.3.4'}, **kwargs)
     settings_mock.assert_called_once_with(repo='stub_repo_name')
     return result
 
 

rhodecode/tests/lib/test_hooks_base.py

@@ -1,141 +1,143 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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 mock
 import pytest
 from rhodecode.model.db import Session, UserLog
 from rhodecode.lib import hooks_base, utils2
 
 
 def test_post_push_truncates_commits(user_regular, repo_stub):
     extras = {
         'ip': '127.0.0.1',
         'username': user_regular.username,
+        'user_id': user_regular.user_id,
         'action': 'push_local',
         'repository': repo_stub.repo_name,
         'scm': 'git',
         'config': '',
         'server_url': 'http://example.com',
         'make_lock': None,
         'user_agent': 'some-client',
         'locked_by': [None],
         'commit_ids': ['abcde12345' * 4] * 30000,
         'is_shadow_repo': False,
     }
     extras = utils2.AttributeDict(extras)
 
     hooks_base.post_push(extras)
 
     # Calculate appropriate action string here
     commit_ids = extras.commit_ids[:400]
 
     entry = UserLog.query().order_by('-user_log_id').first()
     assert entry.action == 'user.push'
     assert entry.action_data['commit_ids'] == commit_ids
     Session().delete(entry)
     Session().commit()
 
 
 def assert_called_with_mock(callable_, expected_mock_name):
     mock_obj = callable_.call_args[0][0]
     mock_name = mock_obj._mock_new_parent._mock_new_name
     assert mock_name == expected_mock_name
 
 
 @pytest.fixture
 def hook_extras(user_regular, repo_stub):
     extras = utils2.AttributeDict({
         'ip': '127.0.0.1',
         'username': user_regular.username,
+        'user_id': user_regular.user_id,
         'action': 'push',
         'repository': repo_stub.repo_name,
         'scm': '',
         'config': '',
         'server_url': 'http://example.com',
         'make_lock': None,
         'user_agent': 'some-client',
         'locked_by': [None],
         'commit_ids': [],
         'is_shadow_repo': False,
     })
     return extras
 
 
 @pytest.mark.parametrize('func, extension, event', [
     (hooks_base.pre_push, 'pre_push_extension', 'RepoPrePushEvent'),
     (hooks_base.post_push, 'post_pull_extension', 'RepoPushEvent'),
     (hooks_base.pre_pull, 'pre_pull_extension', 'RepoPrePullEvent'),
     (hooks_base.post_pull, 'post_push_extension', 'RepoPullEvent'),
 ])
 def test_hooks_propagate(func, extension, event, hook_extras):
     """
     Tests that our hook code propagates to rhodecode extensions and triggers
     the appropriate event.
     """
     extension_mock = mock.Mock()
     events_mock = mock.Mock()
     patches = {
         'Repository': mock.Mock(),
         'events': events_mock,
         extension: extension_mock,
     }
 
     # Clear shadow repo flag.
     hook_extras.is_shadow_repo = False
 
     # Execute hook function.
     with mock.patch.multiple(hooks_base, **patches):
         func(hook_extras)
 
     # Assert that extensions are called and event was fired.
     extension_mock.called_once()
     assert_called_with_mock(events_mock.trigger, event)
 
 
 @pytest.mark.parametrize('func, extension, event', [
     (hooks_base.pre_push, 'pre_push_extension', 'RepoPrePushEvent'),
     (hooks_base.post_push, 'post_pull_extension', 'RepoPushEvent'),
     (hooks_base.pre_pull, 'pre_pull_extension', 'RepoPrePullEvent'),
     (hooks_base.post_pull, 'post_push_extension', 'RepoPullEvent'),
 ])
 def test_hooks_propagates_not_on_shadow(func, extension, event, hook_extras):
     """
     If hooks are called by a request to a shadow repo we only want to run our
     internal hooks code but not external ones like rhodecode extensions or
     trigger an event.
     """
     extension_mock = mock.Mock()
     events_mock = mock.Mock()
     patches = {
         'Repository': mock.Mock(),
         'events': events_mock,
         extension: extension_mock,
     }
 
     # Set shadow repo flag.
     hook_extras.is_shadow_repo = True
 
     # Execute hook function.
     with mock.patch.multiple(hooks_base, **patches):
         func(hook_extras)
 
     # Assert that extensions are *not* called and event was *not* fired.
     assert not extension_mock.called
     assert not events_mock.trigger.called

rhodecode/tests/models/test_pullrequest.py

@@ -1,859 +1,860 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 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 mock
 import pytest
 import textwrap
 
 import rhodecode
 from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.backends.base import (
     MergeResponse, MergeFailureReason, Reference)
 from rhodecode.lib.vcs.exceptions import RepositoryError
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import PullRequest, Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import TEST_USER_ADMIN_LOGIN
 
 
 pytestmark = [
     pytest.mark.backends("git", "hg"),
 ]
 
 
 @pytest.mark.usefixtures('config_stub')
 class TestPullRequestModel(object):
 
     @pytest.fixture
     def pull_request(self, request, backend, pr_util):
         """
         A pull request combined with multiples patches.
         """
         BackendClass = get_backend(backend.alias)
         self.merge_patcher = mock.patch.object(
             BackendClass, 'merge', return_value=MergeResponse(
             False, False, None, MergeFailureReason.UNKNOWN))
         self.workspace_remove_patcher = mock.patch.object(
             BackendClass, 'cleanup_merge_workspace')
 
         self.workspace_remove_mock = self.workspace_remove_patcher.start()
         self.merge_mock = self.merge_patcher.start()
         self.comment_patcher = mock.patch(
             'rhodecode.model.changeset_status.ChangesetStatusModel.set_status')
         self.comment_patcher.start()
         self.notification_patcher = mock.patch(
             'rhodecode.model.notification.NotificationModel.create')
         self.notification_patcher.start()
         self.helper_patcher = mock.patch(
             'rhodecode.lib.helpers.route_path')
         self.helper_patcher.start()
 
         self.hook_patcher = mock.patch.object(PullRequestModel,
                                               '_trigger_pull_request_hook')
         self.hook_mock = self.hook_patcher.start()
 
         self.invalidation_patcher = mock.patch(
             'rhodecode.model.pull_request.ScmModel.mark_for_invalidation')
         self.invalidation_mock = self.invalidation_patcher.start()
 
         self.pull_request = pr_util.create_pull_request(
             mergeable=True, name_suffix=u'ąć')
         self.source_commit = self.pull_request.source_ref_parts.commit_id
         self.target_commit = self.pull_request.target_ref_parts.commit_id
         self.workspace_id = 'pr-%s' % self.pull_request.pull_request_id
 
         @request.addfinalizer
         def cleanup_pull_request():
             calls = [mock.call(
                 self.pull_request, self.pull_request.author, 'create')]
             self.hook_mock.assert_has_calls(calls)
 
             self.workspace_remove_patcher.stop()
             self.merge_patcher.stop()
             self.comment_patcher.stop()
             self.notification_patcher.stop()
             self.helper_patcher.stop()
             self.hook_patcher.stop()
             self.invalidation_patcher.stop()
 
         return self.pull_request
 
     def test_get_all(self, pull_request):
         prs = PullRequestModel().get_all(pull_request.target_repo)
         assert isinstance(prs, list)
         assert len(prs) == 1
 
     def test_count_all(self, pull_request):
         pr_count = PullRequestModel().count_all(pull_request.target_repo)
         assert pr_count == 1
 
     def test_get_awaiting_review(self, pull_request):
         prs = PullRequestModel().get_awaiting_review(pull_request.target_repo)
         assert isinstance(prs, list)
         assert len(prs) == 1
 
     def test_count_awaiting_review(self, pull_request):
         pr_count = PullRequestModel().count_awaiting_review(
             pull_request.target_repo)
         assert pr_count == 1
 
     def test_get_awaiting_my_review(self, pull_request):
         PullRequestModel().update_reviewers(
             pull_request, [(pull_request.author, ['author'], False)],
             pull_request.author)
         prs = PullRequestModel().get_awaiting_my_review(
             pull_request.target_repo, user_id=pull_request.author.user_id)
         assert isinstance(prs, list)
         assert len(prs) == 1
 
     def test_count_awaiting_my_review(self, pull_request):
         PullRequestModel().update_reviewers(
             pull_request, [(pull_request.author, ['author'], False)],
             pull_request.author)
         pr_count = PullRequestModel().count_awaiting_my_review(
             pull_request.target_repo, user_id=pull_request.author.user_id)
         assert pr_count == 1
 
     def test_delete_calls_cleanup_merge(self, pull_request):
         PullRequestModel().delete(pull_request, pull_request.author)
 
         self.workspace_remove_mock.assert_called_once_with(
             self.workspace_id)
 
     def test_close_calls_cleanup_and_hook(self, pull_request):
         PullRequestModel().close_pull_request(
             pull_request, pull_request.author)
 
         self.workspace_remove_mock.assert_called_once_with(
             self.workspace_id)
         self.hook_mock.assert_called_with(
             self.pull_request, self.pull_request.author, 'close')
 
     def test_merge_status(self, pull_request):
         self.merge_mock.return_value = MergeResponse(
             True, False, None, MergeFailureReason.NONE)
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
         assert pull_request.last_merge_status is None
 
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is True
         assert msg.eval() == 'This pull request can be automatically merged.'
         self.merge_mock.assert_called_with(
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts, self.workspace_id, dry_run=True,
             use_rebase=False, close_branch=False)
 
         assert pull_request._last_merge_source_rev == self.source_commit
         assert pull_request._last_merge_target_rev == self.target_commit
         assert pull_request.last_merge_status is MergeFailureReason.NONE
 
         self.merge_mock.reset_mock()
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is True
         assert msg.eval() == 'This pull request can be automatically merged.'
         assert self.merge_mock.called is False
 
     def test_merge_status_known_failure(self, pull_request):
         self.merge_mock.return_value = MergeResponse(
             False, False, None, MergeFailureReason.MERGE_FAILED)
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
         assert pull_request.last_merge_status is None
 
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
         assert (
             msg.eval() ==
             'This pull request cannot be merged because of merge conflicts.')
         self.merge_mock.assert_called_with(
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts, self.workspace_id, dry_run=True,
             use_rebase=False, close_branch=False)
 
         assert pull_request._last_merge_source_rev == self.source_commit
         assert pull_request._last_merge_target_rev == self.target_commit
         assert (
             pull_request.last_merge_status is MergeFailureReason.MERGE_FAILED)
 
         self.merge_mock.reset_mock()
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
         assert (
             msg.eval() ==
             'This pull request cannot be merged because of merge conflicts.')
         assert self.merge_mock.called is False
 
     def test_merge_status_unknown_failure(self, pull_request):
         self.merge_mock.return_value = MergeResponse(
             False, False, None, MergeFailureReason.UNKNOWN)
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
         assert pull_request.last_merge_status is None
 
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
         assert msg.eval() == (
             'This pull request cannot be merged because of an unhandled'
             ' exception.')
         self.merge_mock.assert_called_with(
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts, self.workspace_id, dry_run=True,
             use_rebase=False, close_branch=False)
 
         assert pull_request._last_merge_source_rev is None
         assert pull_request._last_merge_target_rev is None
         assert pull_request.last_merge_status is None
 
         self.merge_mock.reset_mock()
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
         assert msg.eval() == (
             'This pull request cannot be merged because of an unhandled'
             ' exception.')
         assert self.merge_mock.called is True
 
     def test_merge_status_when_target_is_locked(self, pull_request):
         pull_request.target_repo.locked = [1, u'12345.50', 'lock_web']
         status, msg = PullRequestModel().merge_status(pull_request)
         assert status is False
         assert msg.eval() == (
             'This pull request cannot be merged because the target repository'
             ' is locked.')
 
     def test_merge_status_requirements_check_target(self, pull_request):
 
         def has_largefiles(self, repo):
             return repo == pull_request.source_repo
 
         patcher = mock.patch.object(
             PullRequestModel, '_has_largefiles', has_largefiles)
         with patcher:
             status, msg = PullRequestModel().merge_status(pull_request)
 
         assert status is False
         assert msg == 'Target repository large files support is disabled.'
 
     def test_merge_status_requirements_check_source(self, pull_request):
 
         def has_largefiles(self, repo):
             return repo == pull_request.target_repo
 
         patcher = mock.patch.object(
             PullRequestModel, '_has_largefiles', has_largefiles)
         with patcher:
             status, msg = PullRequestModel().merge_status(pull_request)
 
         assert status is False
         assert msg == 'Source repository large files support is disabled.'
 
     def test_merge(self, pull_request, merge_extras):
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         merge_ref = Reference(
             'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
         self.merge_mock.return_value = MergeResponse(
             True, True, merge_ref, MergeFailureReason.NONE)
 
         merge_extras['repository'] = pull_request.target_repo.repo_name
         PullRequestModel().merge(
             pull_request, pull_request.author, extras=merge_extras)
 
         message = (
             u'Merge pull request #{pr_id} from {source_repo} {source_ref_name}'
             u'\n\n {pr_title}'.format(
                 pr_id=pull_request.pull_request_id,
                 source_repo=safe_unicode(
                     pull_request.source_repo.scm_instance().name),
                 source_ref_name=pull_request.source_ref_parts.name,
                 pr_title=safe_unicode(pull_request.title)
             )
         )
         self.merge_mock.assert_called_with(
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts, self.workspace_id,
             user_name=user.username, user_email=user.email, message=message,
             use_rebase=False, close_branch=False
         )
         self.invalidation_mock.assert_called_once_with(
             pull_request.target_repo.repo_name)
 
         self.hook_mock.assert_called_with(
             self.pull_request, self.pull_request.author, 'merge')
 
         pull_request = PullRequest.get(pull_request.pull_request_id)
         assert (
             pull_request.merge_rev ==
             '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
 
     def test_merge_failed(self, pull_request, merge_extras):
         user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
         merge_ref = Reference(
             'type', 'name', '6126b7bfcc82ad2d3deaee22af926b082ce54cc6')
         self.merge_mock.return_value = MergeResponse(
             False, False, merge_ref, MergeFailureReason.MERGE_FAILED)
 
         merge_extras['repository'] = pull_request.target_repo.repo_name
         PullRequestModel().merge(
             pull_request, pull_request.author, extras=merge_extras)
 
         message = (
             u'Merge pull request #{pr_id} from {source_repo} {source_ref_name}'
             u'\n\n {pr_title}'.format(
                 pr_id=pull_request.pull_request_id,
                 source_repo=safe_unicode(
                     pull_request.source_repo.scm_instance().name),
                 source_ref_name=pull_request.source_ref_parts.name,
                 pr_title=safe_unicode(pull_request.title)
             )
         )
         self.merge_mock.assert_called_with(
             pull_request.target_ref_parts,
             pull_request.source_repo.scm_instance(),
             pull_request.source_ref_parts, self.workspace_id,
             user_name=user.username, user_email=user.email, message=message,
             use_rebase=False, close_branch=False
         )
 
         pull_request = PullRequest.get(pull_request.pull_request_id)
         assert self.invalidation_mock.called is False
         assert pull_request.merge_rev is None
 
     def test_get_commit_ids(self, pull_request):
         # The PR has been not merget yet, so expect an exception
         with pytest.raises(ValueError):
             PullRequestModel()._get_commit_ids(pull_request)
 
         # Merge revision is in the revisions list
         pull_request.merge_rev = pull_request.revisions[0]
         commit_ids = PullRequestModel()._get_commit_ids(pull_request)
         assert commit_ids == pull_request.revisions
 
         # Merge revision is not in the revisions list
         pull_request.merge_rev = 'f000' * 10
         commit_ids = PullRequestModel()._get_commit_ids(pull_request)
         assert commit_ids == pull_request.revisions + [pull_request.merge_rev]
 
     def test_get_diff_from_pr_version(self, pull_request):
         source_repo = pull_request.source_repo
         source_ref_id = pull_request.source_ref_parts.commit_id
         target_ref_id = pull_request.target_ref_parts.commit_id
         diff = PullRequestModel()._get_diff_from_pr_or_version(
             source_repo, source_ref_id, target_ref_id, context=6)
         assert 'file_1' in diff.raw
 
     def test_generate_title_returns_unicode(self):
         title = PullRequestModel().generate_pullrequest_title(
             source='source-dummy',
             source_ref='source-ref-dummy',
             target='target-dummy',
         )
         assert type(title) == unicode
 
 
 @pytest.mark.usefixtures('config_stub')
 class TestIntegrationMerge(object):
     @pytest.mark.parametrize('extra_config', (
         {'vcs.hooks.protocol': 'http', 'vcs.hooks.direct_calls': False},
     ))
     def test_merge_triggers_push_hooks(
             self, pr_util, user_admin, capture_rcextensions, merge_extras,
             extra_config):
         pull_request = pr_util.create_pull_request(
             approved=True, mergeable=True)
         # TODO: johbo: Needed for sqlite, try to find an automatic way for it
         merge_extras['repository'] = pull_request.target_repo.repo_name
         Session().commit()
 
         with mock.patch.dict(rhodecode.CONFIG, extra_config, clear=False):
             merge_state = PullRequestModel().merge(
                 pull_request, user_admin, extras=merge_extras)
 
         assert merge_state.executed
         assert 'pre_push' in capture_rcextensions
         assert 'post_push' in capture_rcextensions
 
     def test_merge_can_be_rejected_by_pre_push_hook(
             self, pr_util, user_admin, capture_rcextensions, merge_extras):
         pull_request = pr_util.create_pull_request(
             approved=True, mergeable=True)
         # TODO: johbo: Needed for sqlite, try to find an automatic way for it
         merge_extras['repository'] = pull_request.target_repo.repo_name
         Session().commit()
 
         with mock.patch('rhodecode.EXTENSIONS.PRE_PUSH_HOOK') as pre_pull:
             pre_pull.side_effect = RepositoryError("Disallow push!")
             merge_status = PullRequestModel().merge(
                 pull_request, user_admin, extras=merge_extras)
 
         assert not merge_status.executed
         assert 'pre_push' not in capture_rcextensions
         assert 'post_push' not in capture_rcextensions
 
     def test_merge_fails_if_target_is_locked(
             self, pr_util, user_regular, merge_extras):
         pull_request = pr_util.create_pull_request(
             approved=True, mergeable=True)
         locked_by = [user_regular.user_id + 1, 12345.50, 'lock_web']
         pull_request.target_repo.locked = locked_by
         # TODO: johbo: Check if this can work based on the database, currently
         # all data is pre-computed, that's why just updating the DB is not
         # enough.
         merge_extras['locked_by'] = locked_by
         merge_extras['repository'] = pull_request.target_repo.repo_name
         # TODO: johbo: Needed for sqlite, try to find an automatic way for it
         Session().commit()
         merge_status = PullRequestModel().merge(
             pull_request, user_regular, extras=merge_extras)
         assert not merge_status.executed
 
 
 @pytest.mark.parametrize('use_outdated, inlines_count, outdated_count', [
     (False, 1, 0),
     (True, 0, 1),
 ])
 def test_outdated_comments(
         pr_util, use_outdated, inlines_count, outdated_count, config_stub):
     pull_request = pr_util.create_pull_request()
     pr_util.create_inline_comment(file_path='not_in_updated_diff')
 
     with outdated_comments_patcher(use_outdated) as outdated_comment_mock:
         pr_util.add_one_commit()
         assert_inline_comments(
             pull_request, visible=inlines_count, outdated=outdated_count)
     outdated_comment_mock.assert_called_with(pull_request)
 
 
 @pytest.fixture
 def merge_extras(user_regular):
     """
     Context for the vcs operation when running a merge.
     """
     extras = {
         'ip': '127.0.0.1',
         'username': user_regular.username,
+        'user_id': user_regular.user_id,
         'action': 'push',
         'repository': 'fake_target_repo_name',
         'scm': 'git',
         'config': 'fake_config_ini_path',
         'make_lock': None,
         'locked_by': [None, None, None],
         'server_url': 'http://test.example.com:5000',
         'hooks': ['push', 'pull'],
         'is_shadow_repo': False,
     }
     return extras
 
 
 @pytest.mark.usefixtures('config_stub')
 class TestUpdateCommentHandling(object):
 
     @pytest.fixture(autouse=True, scope='class')
     def enable_outdated_comments(self, request, baseapp):
         config_patch = mock.patch.dict(
             'rhodecode.CONFIG', {'rhodecode_use_outdated_comments': True})
         config_patch.start()
 
         @request.addfinalizer
         def cleanup():
             config_patch.stop()
 
     def test_comment_stays_unflagged_on_unchanged_diff(self, pr_util):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [FileNode('file_b', 'test_content\n')]},
             {'message': 'c', 'added': [FileNode('file_c', 'test_content\n')]},
         ]
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
         pr_util.create_inline_comment(file_path='file_b')
         pr_util.add_one_commit(head='c')
 
         assert_inline_comments(pull_request, visible=1, outdated=0)
 
     def test_comment_stays_unflagged_on_change_above(self, pr_util):
         original_content = ''.join(
             ['line {}\n'.format(x) for x in range(1, 11)])
         updated_content = 'new_line_at_top\n' + original_content
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [FileNode('file_b', original_content)]},
             {'message': 'c', 'changed': [FileNode('file_b', updated_content)]},
         ]
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
 
         with outdated_comments_patcher():
             comment = pr_util.create_inline_comment(
                 line_no=u'n8', file_path='file_b')
             pr_util.add_one_commit(head='c')
 
         assert_inline_comments(pull_request, visible=1, outdated=0)
         assert comment.line_no == u'n9'
 
     def test_comment_stays_unflagged_on_change_below(self, pr_util):
         original_content = ''.join(['line {}\n'.format(x) for x in range(10)])
         updated_content = original_content + 'new_line_at_end\n'
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [FileNode('file_b', original_content)]},
             {'message': 'c', 'changed': [FileNode('file_b', updated_content)]},
         ]
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
         pr_util.create_inline_comment(file_path='file_b')
         pr_util.add_one_commit(head='c')
 
         assert_inline_comments(pull_request, visible=1, outdated=0)
 
     @pytest.mark.parametrize('line_no', ['n4', 'o4', 'n10', 'o9'])
     def test_comment_flagged_on_change_around_context(self, pr_util, line_no):
         base_lines = ['line {}\n'.format(x) for x in range(1, 13)]
         change_lines = list(base_lines)
         change_lines.insert(6, 'line 6a added\n')
 
         # Changes on the last line of sight
         update_lines = list(change_lines)
         update_lines[0] = 'line 1 changed\n'
         update_lines[-1] = 'line 12 changed\n'
 
         def file_b(lines):
             return FileNode('file_b', ''.join(lines))
 
         commits = [
             {'message': 'a', 'added': [file_b(base_lines)]},
             {'message': 'b', 'changed': [file_b(change_lines)]},
             {'message': 'c', 'changed': [file_b(update_lines)]},
         ]
 
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
         pr_util.create_inline_comment(line_no=line_no, file_path='file_b')
 
         with outdated_comments_patcher():
             pr_util.add_one_commit(head='c')
             assert_inline_comments(pull_request, visible=0, outdated=1)
 
     @pytest.mark.parametrize("change, content", [
         ('changed', 'changed\n'),
         ('removed', ''),
     ], ids=['changed', 'removed'])
     def test_comment_flagged_on_change(self, pr_util, change, content):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [FileNode('file_b', 'test_content\n')]},
             {'message': 'c', change: [FileNode('file_b', content)]},
         ]
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'])
         pr_util.create_inline_comment(file_path='file_b')
 
         with outdated_comments_patcher():
             pr_util.add_one_commit(head='c')
             assert_inline_comments(pull_request, visible=0, outdated=1)
 
 
 @pytest.mark.usefixtures('config_stub')
 class TestUpdateChangedFiles(object):
 
     def test_no_changes_on_unchanged_diff(self, pr_util):
         commits = [
             {'message': 'a'},
             {'message': 'b',
              'added': [FileNode('file_b', 'test_content b\n')]},
             {'message': 'c',
              'added': [FileNode('file_c', 'test_content c\n')]},
         ]
         # open a PR from a to b, adding file_b
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'],
             name_suffix='per-file-review')
 
         # modify PR adding new file file_c
         pr_util.add_one_commit(head='c')
 
         assert_pr_file_changes(
             pull_request,
             added=['file_c'],
             modified=[],
             removed=[])
 
     def test_modify_and_undo_modification_diff(self, pr_util):
         commits = [
             {'message': 'a'},
             {'message': 'b',
              'added': [FileNode('file_b', 'test_content b\n')]},
             {'message': 'c',
              'changed': [FileNode('file_b', 'test_content b modified\n')]},
             {'message': 'd',
              'changed': [FileNode('file_b', 'test_content b\n')]},
         ]
         # open a PR from a to b, adding file_b
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'],
             name_suffix='per-file-review')
 
         # modify PR modifying file file_b
         pr_util.add_one_commit(head='c')
 
         assert_pr_file_changes(
             pull_request,
             added=[],
             modified=['file_b'],
             removed=[])
 
         # move the head again to d, which rollbacks change,
         # meaning we should indicate no changes
         pr_util.add_one_commit(head='d')
 
         assert_pr_file_changes(
             pull_request,
             added=[],
             modified=[],
             removed=[])
 
     def test_updated_all_files_in_pr(self, pr_util):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [
                 FileNode('file_a', 'test_content a\n'),
                 FileNode('file_b', 'test_content b\n'),
                 FileNode('file_c', 'test_content c\n')]},
             {'message': 'c', 'changed': [
                 FileNode('file_a', 'test_content a changed\n'),
                 FileNode('file_b', 'test_content b changed\n'),
                 FileNode('file_c', 'test_content c changed\n')]},
         ]
         # open a PR from a to b, changing 3 files
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'],
             name_suffix='per-file-review')
 
         pr_util.add_one_commit(head='c')
 
         assert_pr_file_changes(
             pull_request,
             added=[],
             modified=['file_a', 'file_b', 'file_c'],
             removed=[])
 
     def test_updated_and_removed_all_files_in_pr(self, pr_util):
         commits = [
             {'message': 'a'},
             {'message': 'b', 'added': [
                 FileNode('file_a', 'test_content a\n'),
                 FileNode('file_b', 'test_content b\n'),
                 FileNode('file_c', 'test_content c\n')]},
             {'message': 'c', 'removed': [
                 FileNode('file_a', 'test_content a changed\n'),
                 FileNode('file_b', 'test_content b changed\n'),
                 FileNode('file_c', 'test_content c changed\n')]},
         ]
         # open a PR from a to b, removing 3 files
         pull_request = pr_util.create_pull_request(
             commits=commits, target_head='a', source_head='b', revisions=['b'],
             name_suffix='per-file-review')
 
         pr_util.add_one_commit(head='c')
 
         assert_pr_file_changes(
             pull_request,
             added=[],
             modified=[],
             removed=['file_a', 'file_b', 'file_c'])
 
 
 def test_update_writes_snapshot_into_pull_request_version(pr_util, config_stub):
     model = PullRequestModel()
     pull_request = pr_util.create_pull_request()
     pr_util.update_source_repository()
 
     model.update_commits(pull_request)
 
     # Expect that it has a version entry now
     assert len(model.get_versions(pull_request)) == 1
 
 
 def test_update_skips_new_version_if_unchanged(pr_util, config_stub):
     pull_request = pr_util.create_pull_request()
     model = PullRequestModel()
     model.update_commits(pull_request)
 
     # Expect that it still has no versions
     assert len(model.get_versions(pull_request)) == 0
 
 
 def test_update_assigns_comments_to_the_new_version(pr_util, config_stub):
     model = PullRequestModel()
     pull_request = pr_util.create_pull_request()
     comment = pr_util.create_comment()
     pr_util.update_source_repository()
 
     model.update_commits(pull_request)
 
     # Expect that the comment is linked to the pr version now
     assert comment.pull_request_version == model.get_versions(pull_request)[0]
 
 
 def test_update_adds_a_comment_to_the_pull_request_about_the_change(pr_util, config_stub):
     model = PullRequestModel()
     pull_request = pr_util.create_pull_request()
     pr_util.update_source_repository()
     pr_util.update_source_repository()
 
     model.update_commits(pull_request)
 
     # Expect to find a new comment about the change
     expected_message = textwrap.dedent(
         """\
         Pull request updated. Auto status change to |under_review|
 
         .. role:: added
         .. role:: removed
         .. parsed-literal::
 
           Changed commits:
             * :added:`1 added`
             * :removed:`0 removed`
 
           Changed files:
             * `A file_2 <#a_c--92ed3b5f07b4>`_
 
         .. |under_review| replace:: *"Under Review"*"""
     )
     pull_request_comments = sorted(
         pull_request.comments, key=lambda c: c.modified_at)
     update_comment = pull_request_comments[-1]
     assert update_comment.text == expected_message
 
 
 def test_create_version_from_snapshot_updates_attributes(pr_util, config_stub):
     pull_request = pr_util.create_pull_request()
 
     # Avoiding default values
     pull_request.status = PullRequest.STATUS_CLOSED
     pull_request._last_merge_source_rev = "0" * 40
     pull_request._last_merge_target_rev = "1" * 40
     pull_request.last_merge_status = 1
     pull_request.merge_rev = "2" * 40
 
     # Remember automatic values
     created_on = pull_request.created_on
     updated_on = pull_request.updated_on
 
     # Create a new version of the pull request
     version = PullRequestModel()._create_version_from_snapshot(pull_request)
 
     # Check attributes
     assert version.title == pr_util.create_parameters['title']
     assert version.description == pr_util.create_parameters['description']
     assert version.status == PullRequest.STATUS_CLOSED
 
     # versions get updated created_on
     assert version.created_on != created_on
 
     assert version.updated_on == updated_on
     assert version.user_id == pull_request.user_id
     assert version.revisions == pr_util.create_parameters['revisions']
     assert version.source_repo == pr_util.source_repository
     assert version.source_ref == pr_util.create_parameters['source_ref']
     assert version.target_repo == pr_util.target_repository
     assert version.target_ref == pr_util.create_parameters['target_ref']
     assert version._last_merge_source_rev == pull_request._last_merge_source_rev
     assert version._last_merge_target_rev == pull_request._last_merge_target_rev
     assert version.last_merge_status == pull_request.last_merge_status
     assert version.merge_rev == pull_request.merge_rev
     assert version.pull_request == pull_request
 
 
 def test_link_comments_to_version_only_updates_unlinked_comments(pr_util, config_stub):
     version1 = pr_util.create_version_of_pull_request()
     comment_linked = pr_util.create_comment(linked_to=version1)
     comment_unlinked = pr_util.create_comment()
     version2 = pr_util.create_version_of_pull_request()
 
     PullRequestModel()._link_comments_to_version(version2)
 
     # Expect that only the new comment is linked to version2
     assert (
         comment_unlinked.pull_request_version_id ==
         version2.pull_request_version_id)
     assert (
         comment_linked.pull_request_version_id ==
         version1.pull_request_version_id)
     assert (
         comment_unlinked.pull_request_version_id !=
         comment_linked.pull_request_version_id)
 
 
 def test_calculate_commits():
     old_ids = [1, 2, 3]
     new_ids = [1, 3, 4, 5]
     change = PullRequestModel()._calculate_commit_id_changes(old_ids, new_ids)
     assert change.added == [4, 5]
     assert change.common == [1, 3]
     assert change.removed == [2]
     assert change.total == [1, 3, 4, 5]
 
 
 def assert_inline_comments(pull_request, visible=None, outdated=None):
     if visible is not None:
         inline_comments = CommentsModel().get_inline_comments(
             pull_request.target_repo.repo_id, pull_request=pull_request)
         inline_cnt = CommentsModel().get_inline_comments_count(
             inline_comments)
         assert inline_cnt == visible
     if outdated is not None:
         outdated_comments = CommentsModel().get_outdated_comments(
             pull_request.target_repo.repo_id, pull_request)
         assert len(outdated_comments) == outdated
 
 
 def assert_pr_file_changes(
         pull_request, added=None, modified=None, removed=None):
     pr_versions = PullRequestModel().get_versions(pull_request)
     # always use first version, ie original PR to calculate changes
     pull_request_version = pr_versions[0]
     old_diff_data, new_diff_data = PullRequestModel()._generate_update_diffs(
         pull_request, pull_request_version)
     file_changes = PullRequestModel()._calculate_file_changes(
         old_diff_data, new_diff_data)
 
     assert added == file_changes.added, \
         'expected added:%s vs value:%s' % (added, file_changes.added)
     assert modified == file_changes.modified, \
         'expected modified:%s vs value:%s' % (modified, file_changes.modified)
     assert removed == file_changes.removed, \
         'expected removed:%s vs value:%s' % (removed, file_changes.removed)
 
 
 def outdated_comments_patcher(use_outdated=True):
     return mock.patch.object(
         CommentsModel, 'use_outdated_comments',
         return_value=use_outdated)