integrations: add recursive repo group scope to allow integrations

to cascade into all descendant repositories, fixes  #4225

rhodecode/integrations/views.py

@@ -1,385 +1,392 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2016  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 pylons
 import deform
 import logging
 import colander
 import peppercorn
 import webhelpers.paginate
 
 from pyramid.httpexceptions import HTTPFound, HTTPForbidden, HTTPBadRequest
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode.lib import auth
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
 from rhodecode.lib.utils2 import safe_int
 from rhodecode.lib.helpers import Page
 from rhodecode.model.db import Repository, RepoGroup, Session, Integration
 from rhodecode.model.scm import ScmModel
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.admin.navigation import navigation_list
 from rhodecode.translation import _
 from rhodecode.integrations import integration_type_registry
 from rhodecode.model.validation_schema.schemas.integration_schema import (
-    make_integration_schema)
+    make_integration_schema, IntegrationScopeType)
 
 log = logging.getLogger(__name__)
 
 
 class IntegrationSettingsViewBase(object):
     """ Base Integration settings view used by both repo / global settings """
 
     def __init__(self, context, request):
         self.context = context
         self.request = request
         self._load_general_context()
 
         if not self.perm_check(request.user):
             raise HTTPForbidden()
 
     def _load_general_context(self):
         """
         This avoids boilerplate for repo/global+list/edit+views/templates
         by doing all possible contexts at the same time however it should
         be split up into separate functions once more "contexts" exist
         """
 
         self.IntegrationType = None
         self.repo = None
         self.repo_group = None
         self.integration = None
         self.integrations = {}
 
         request = self.request
 
         if 'repo_name' in request.matchdict:  # in repo settings context
             repo_name = request.matchdict['repo_name']
             self.repo = Repository.get_by_repo_name(repo_name)
 
         if 'repo_group_name' in request.matchdict: # in group settings context
             repo_group_name = request.matchdict['repo_group_name']
             self.repo_group = RepoGroup.get_by_group_name(repo_group_name)
 
 
         if 'integration' in request.matchdict:  # integration type context
             integration_type = request.matchdict['integration']
             self.IntegrationType = integration_type_registry[integration_type]
 
         if 'integration_id' in request.matchdict:  # single integration context
             integration_id = request.matchdict['integration_id']
             self.integration = Integration.get(integration_id)
 
             # extra perms check just in case
             if not self._has_perms_for_integration(self.integration):
                 raise HTTPForbidden()
 
         self.settings = self.integration and self.integration.settings or {}
         self.admin_view = not (self.repo or self.repo_group)
 
     def _has_perms_for_integration(self, integration):
         perms = self.request.user.permissions
 
         if 'hg.admin' in perms['global']:
             return True
 
         if integration.repo:
             return perms['repositories'].get(
                 integration.repo.repo_name) == 'repository.admin'
 
         if integration.repo_group:
             return perms['repositories_groups'].get(
                 integration.repo_group.group_name) == 'group.admin'
 
         return False
 
     def _template_c_context(self):
         # TODO: dan: this is a stopgap in order to inherit from current pylons
         # based admin/repo settings templates - this should be removed entirely
         # after port to pyramid
 
         c = pylons.tmpl_context
         c.active = 'integrations'
         c.rhodecode_user = self.request.user
         c.repo = self.repo
         c.repo_group = self.repo_group
         c.repo_name = self.repo and self.repo.repo_name or None
         c.repo_group_name = self.repo_group and self.repo_group.group_name or None
 
         if self.repo:
             c.repo_info = self.repo
             c.rhodecode_db_repo = self.repo
             c.repository_pull_requests = ScmModel().get_pull_requests(self.repo)
         else:
             c.navlist = navigation_list(self.request)
 
         return c
 
     def _form_schema(self):
         schema = make_integration_schema(IntegrationType=self.IntegrationType,
                                          settings=self.settings)
 
         # returns a clone, important if mutating the schema later
         return schema.bind(
             permissions=self.request.user.permissions,
             no_scope=not self.admin_view)
 
 
     def _form_defaults(self):
         defaults = {}
 
         if self.integration:
             defaults['settings'] = self.integration.settings or {}
             defaults['options'] = {
                 'name': self.integration.name,
                 'enabled': self.integration.enabled,
-                'scope': self.integration.scope,
+                'scope': {
+                    'repo': self.integration.repo,
+                    'repo_group': self.integration.repo_group,
+                    'child_repos_only': self.integration.child_repos_only,
+                },
             }
         else:
             if self.repo:
                 scope = _('{repo_name} repository').format(
                     repo_name=self.repo.repo_name)
             elif self.repo_group:
                 scope = _('{repo_group_name} repo group').format(
                     repo_group_name=self.repo_group.group_name)
             else:
                 scope = _('Global')
 
             defaults['options'] = {
                 'enabled': True,
                 'name': _('{name} integration').format(
                     name=self.IntegrationType.display_name),
             }
-            if self.repo:
-                defaults['options']['scope'] = self.repo
-            elif self.repo_group:
-                defaults['options']['scope'] = self.repo_group
+            defaults['options']['scope'] = {
+                'repo': self.repo,
+                'repo_group': self.repo_group,
+            }
 
         return defaults
 
     def _delete_integration(self, integration):
         Session().delete(self.integration)
         Session().commit()
         self.request.session.flash(
             _('Integration {integration_name} deleted successfully.').format(
                 integration_name=self.integration.name),
             queue='success')
 
         if self.repo:
             redirect_to = self.request.route_url(
                 'repo_integrations_home', repo_name=self.repo.repo_name)
         elif self.repo_group:
             redirect_to = self.request.route_url(
                 'repo_group_integrations_home',
                 repo_group_name=self.repo_group.group_name)
         else:
             redirect_to = self.request.route_url('global_integrations_home')
         raise HTTPFound(redirect_to)
 
     def settings_get(self, defaults=None, form=None):
         """
         View that displays the integration settings as a form.
         """
 
         defaults = defaults or self._form_defaults()
         schema = self._form_schema()
 
         if self.integration:
             buttons = ('submit', 'delete')
         else:
             buttons = ('submit',)
 
         form = form or deform.Form(schema, appstruct=defaults, buttons=buttons)
 
         template_context = {
             'form': form,
             'current_IntegrationType': self.IntegrationType,
             'integration': self.integration,
             'c': self._template_c_context(),
         }
 
         return template_context
 
     @auth.CSRFRequired()
     def settings_post(self):
         """
         View that validates and stores the integration settings.
         """
         controls = self.request.POST.items()
         pstruct = peppercorn.parse(controls)
 
         if self.integration and pstruct.get('delete'):
             return self._delete_integration(self.integration)
 
         schema = self._form_schema()
 
         skip_settings_validation = False
         if self.integration and 'enabled' not in pstruct.get('options', {}):
             skip_settings_validation = True
             schema['settings'].validator = None
             for field in schema['settings'].children:
                 field.validator = None
                 field.missing = ''
 
         if self.integration:
             buttons = ('submit', 'delete')
         else:
             buttons = ('submit',)
 
         form = deform.Form(schema, buttons=buttons)
 
         if not self.admin_view:
             # scope is read only field in these cases, and has to be added
             options = pstruct.setdefault('options', {})
             if 'scope' not in options:
-                if self.repo:
-                    options['scope'] = 'repo:{}'.format(self.repo.repo_name)
-                elif self.repo_group:
-                    options['scope'] = 'repogroup:{}'.format(
-                        self.repo_group.group_name)
+                options['scope'] = IntegrationScopeType().serialize(None, {
+                    'repo': self.repo,
+                    'repo_group': self.repo_group,
+                })
 
         try:
             valid_data = form.validate_pstruct(pstruct)
         except deform.ValidationFailure as e:
             self.request.session.flash(
                 _('Errors exist when saving integration settings. '
                   'Please check the form inputs.'),
                 queue='error')
             return self.settings_get(form=e)
 
         if not self.integration:
             self.integration = Integration()
             self.integration.integration_type = self.IntegrationType.key
             Session().add(self.integration)
 
         scope = valid_data['options']['scope']
 
         IntegrationModel().update_integration(self.integration,
             name=valid_data['options']['name'],
             enabled=valid_data['options']['enabled'],
             settings=valid_data['settings'],
-            scope=scope)
+            repo=scope['repo'],
+            repo_group=scope['repo_group'],
+            child_repos_only=scope['child_repos_only'],
+        )
+
 
         self.integration.settings = valid_data['settings']
         Session().commit()
         # Display success message and redirect.
         self.request.session.flash(
             _('Integration {integration_name} updated successfully.').format(
                 integration_name=self.IntegrationType.display_name),
             queue='success')
 
 
         # if integration scope changes, we must redirect to the right place
         # keeping in mind if the original view was for /repo/ or /_admin/
         admin_view = not (self.repo or self.repo_group)
 
-        if isinstance(self.integration.scope, Repository) and not admin_view:
+        if self.integration.repo and not admin_view:
             redirect_to = self.request.route_path(
                 'repo_integrations_edit',
-                repo_name=self.integration.scope.repo_name,
+                repo_name=self.integration.repo.repo_name,
                 integration=self.integration.integration_type,
                 integration_id=self.integration.integration_id)
-        elif isinstance(self.integration.scope, RepoGroup) and not admin_view:
+        elif self.integration.repo_group and not admin_view:
             redirect_to = self.request.route_path(
                 'repo_group_integrations_edit',
-                repo_group_name=self.integration.scope.group_name,
+                repo_group_name=self.integration.repo_group.group_name,
                 integration=self.integration.integration_type,
                 integration_id=self.integration.integration_id)
         else:
             redirect_to = self.request.route_path(
                 'global_integrations_edit',
                 integration=self.integration.integration_type,
                 integration_id=self.integration.integration_id)
 
         return HTTPFound(redirect_to)
 
     def index(self):
         """ List integrations """
         if self.repo:
             scope = self.repo
         elif self.repo_group:
             scope = self.repo_group
         else:
             scope = 'all'
 
         integrations = []
 
         for integration in IntegrationModel().get_integrations(
                         scope=scope, IntegrationType=self.IntegrationType):
 
             # extra permissions check *just in case*
             if not self._has_perms_for_integration(integration):
                 continue
             integrations.append(integration)
 
         sort_arg = self.request.GET.get('sort', 'name:asc')
         if ':' in sort_arg:
             sort_field, sort_dir = sort_arg.split(':')
         else:
             sort_field = sort_arg, 'asc'
 
         assert sort_field in ('name', 'integration_type', 'enabled', 'scope')
 
         integrations.sort(
             key=lambda x: getattr(x[1], sort_field), reverse=(sort_dir=='desc'))
 
 
         page_url = webhelpers.paginate.PageURL(
             self.request.path, self.request.GET)
         page = safe_int(self.request.GET.get('page', 1), 1)
 
         integrations = Page(integrations, page=page, items_per_page=10,
                                url=page_url)
 
         template_context = {
             'sort_field': sort_field,
             'rev_sort_dir': sort_dir != 'desc' and 'desc' or 'asc',
             'current_IntegrationType': self.IntegrationType,
             'integrations_list': integrations,
             'available_integrations': integration_type_registry,
             'c': self._template_c_context(),
             'request': self.request,
         }
         return template_context
 
     def new_integration(self):
         template_context = {
             'available_integrations': integration_type_registry,
             'c': self._template_c_context(),
         }
         return template_context
 
 class GlobalIntegrationsView(IntegrationSettingsViewBase):
     def perm_check(self, user):
         return auth.HasPermissionAll('hg.admin').check_permissions(user=user)
 
 
 class RepoIntegrationsView(IntegrationSettingsViewBase):
     def perm_check(self, user):
         return auth.HasRepoPermissionAll('repository.admin'
             )(repo_name=self.repo.repo_name, user=user)
 
 
 class RepoGroupIntegrationsView(IntegrationSettingsViewBase):
     def perm_check(self, user):
         return auth.HasRepoGroupPermissionAll('group.admin'
             )(group_name=self.repo_group.group_name, user=user)
 

rhodecode/model/integration.py

@@ -1,213 +1,222 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2011-2016  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/
 
 
 """
 Model for integrations
 """
 
 
 import logging
 import traceback
 
 from pylons import tmpl_context as c
 from pylons.i18n.translation import _, ungettext
 from sqlalchemy import or_, and_
 from sqlalchemy.sql.expression import false, true
 from mako import exceptions
 
 import rhodecode
 from rhodecode import events
 from rhodecode.lib import helpers as h
 from rhodecode.lib.caching_query import FromCache
 from rhodecode.lib.utils import PartialRenderer
 from rhodecode.model import BaseModel
 from rhodecode.model.db import Integration, User, Repository, RepoGroup
 from rhodecode.model.meta import Session
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 
 log = logging.getLogger(__name__)
 
 
 class IntegrationModel(BaseModel):
 
     cls = Integration
 
     def __get_integration(self, integration):
         if isinstance(integration, Integration):
             return integration
         elif isinstance(integration, (int, long)):
             return self.sa.query(Integration).get(integration)
         else:
             if integration:
                 raise Exception('integration must be int, long or Instance'
                                 ' of Integration got %s' % type(integration))
 
-    def create(self, IntegrationType, name, enabled, scope, settings):
+    def create(self, IntegrationType, name, enabled, repo, repo_group,
+        child_repos_only, settings):
         """ Create an IntegrationType integration """
         integration = Integration()
         integration.integration_type = IntegrationType.key
         self.sa.add(integration)
-        self.update_integration(integration, name, enabled, scope, settings)
+        self.update_integration(integration, name, enabled, repo, repo_group,
+                                child_repos_only, settings)
         self.sa.commit()
         return integration
 
-    def update_integration(self, integration, name, enabled, scope, settings):
-        """
-        :param scope: one of ['global', 'root_repos', <RepoGroup>. <Repository>]
-        """
-
+    def update_integration(self, integration, name, enabled, repo, repo_group,
+        child_repos_only, settings):
         integration = self.__get_integration(integration)
 
-        integration.scope = scope
+        integration.repo = repo
+        integration.repo_group = repo_group
+        integration.child_repos_only = child_repos_only
         integration.name = name
         integration.enabled = enabled
         integration.settings = settings
 
         return integration
 
     def delete(self, integration):
         integration = self.__get_integration(integration)
         if integration:
             self.sa.delete(integration)
             return True
         return False
 
     def get_integration_handler(self, integration):
         TypeClass = integration_type_registry.get(integration.integration_type)
         if not TypeClass:
             log.error('No class could be found for integration type: {}'.format(
                 integration.integration_type))
             return None
 
         return TypeClass(integration.settings)
 
     def send_event(self, integration, event):
         """ Send an event to an integration """
         handler = self.get_integration_handler(integration)
         if handler:
             handler.send_event(event)
 
     def get_integrations(self, scope, IntegrationType=None):
         """
         Return integrations for a scope, which must be one of:
 
         'all' - every integration, global/repogroup/repo
         'global' - global integrations only
         <Repository> instance - integrations for this repo only
         <RepoGroup> instance - integrations for this repogroup only
         """
 
         if isinstance(scope, Repository):
             query = self.sa.query(Integration).filter(
                 Integration.repo==scope)
         elif isinstance(scope, RepoGroup):
             query = self.sa.query(Integration).filter(
                 Integration.repo_group==scope)
         elif scope == 'global':
             # global integrations
             query = self.sa.query(Integration).filter(
                 and_(Integration.repo_id==None, Integration.repo_group_id==None)
             )
-        elif scope == 'root_repos':
+        elif scope == 'root-repos':
             query = self.sa.query(Integration).filter(
                 and_(Integration.repo_id==None,
                      Integration.repo_group_id==None,
                      Integration.child_repos_only==True)
             )
         elif scope == 'all':
             query = self.sa.query(Integration)
         else:
             raise Exception(
                 "invalid `scope`, must be one of: "
                 "['global', 'all', <Repository>, <RepoGroup>]")
 
         if IntegrationType is not None:
             query = query.filter(
                 Integration.integration_type==IntegrationType.key)
 
         result = []
         for integration in query.all():
             IntType = integration_type_registry.get(integration.integration_type)
             result.append((IntType, integration))
         return result
 
     def get_for_event(self, event, cache=False):
         """
         Get integrations that match an event
         """
         query = self.sa.query(
             Integration
         ).filter(
             Integration.enabled==True
         )
 
         global_integrations_filter = and_(
             Integration.repo_id==None,
             Integration.repo_group_id==None,
             Integration.child_repos_only==False,
         )
 
         if isinstance(event, events.RepoEvent):
             root_repos_integrations_filter = and_(
                 Integration.repo_id==None,
                 Integration.repo_group_id==None,
                 Integration.child_repos_only==True,
             )
 
             clauses = [
                 global_integrations_filter,
             ]
 
             # repo integrations
             if event.repo.repo_id: # pre create events dont have a repo_id yet
                 clauses.append(
                     Integration.repo_id==event.repo.repo_id
                 )
 
             if event.repo.group:
                 clauses.append(
-                    Integration.repo_group_id == event.repo.group.group_id
+                    and_(
+                        Integration.repo_group_id==event.repo.group.group_id,
+                        Integration.child_repos_only==True
+                    )
                 )
-                # repo group cascade to kids (maybe implement this sometime?)
-                # clauses.append(Integration.repo_group_id.in_(
-                #     [group.group_id for group in
-                #     event.repo.groups_with_parents]
-                # ))
+                # repo group cascade to kids
+                clauses.append(
+                    and_(
+                        Integration.repo_group_id.in_(
+                            [group.group_id for group in
+                            event.repo.groups_with_parents]
+                        ),
+                        Integration.child_repos_only==False
+                    )
+                )
 
 
             if not event.repo.group: # root repo
                 clauses.append(root_repos_integrations_filter)
 
             query = query.filter(or_(*clauses))
 
             if cache:
                 query = query.options(FromCache(
                     "sql_cache_short",
                     "get_enabled_repo_integrations_%i" % event.repo.repo_id))
         else: # only global integrations
             query = query.filter(global_integrations_filter)
             if cache:
                 query = query.options(FromCache(
                     "sql_cache_short", "get_enabled_global_integrations"))
 
         result = query.all()
         return result
  No newline at end of file

rhodecode/model/validation_schema/schemas/integration_schema.py

@@ -1,187 +1,226 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  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 deform
 import colander
 
 from rhodecode.translation import _
 from rhodecode.model.db import Repository, RepoGroup
 from rhodecode.model.validation_schema import validators, preparers
 
 
 def integration_scope_choices(permissions):
     """
     Return list of (value, label) choices for integration scopes depending on
     the permissions
     """
     result = [('', _('Pick a scope:'))]
     if 'hg.admin' in permissions['global']:
         result.extend([
            ('global', _('Global (all repositories)')),
-           ('root_repos', _('Top level repositories only')),
+           ('root-repos', _('Top level repositories only')),
         ])
 
     repo_choices = [
         ('repo:%s' % repo_name, '/' + repo_name)
         for repo_name, repo_perm
         in permissions['repositories'].items()
         if repo_perm == 'repository.admin'
     ]
     repogroup_choices = [
-        ('repogroup:%s' % repo_group_name, '/' + repo_group_name + ' (group)')
+        ('repogroup:%s' % repo_group_name, '/' + repo_group_name + '/ (child repos only)')
+        for repo_group_name, repo_group_perm
+        in permissions['repositories_groups'].items()
+        if repo_group_perm == 'group.admin'
+    ]
+    repogroup_recursive_choices = [
+        ('repogroup-recursive:%s' % repo_group_name, '/' + repo_group_name + '/ (recursive)')
         for repo_group_name, repo_group_perm
         in permissions['repositories_groups'].items()
         if repo_group_perm == 'group.admin'
     ]
     result.extend(
-        sorted(repogroup_choices + repo_choices,
+        sorted(repogroup_recursive_choices + repogroup_choices + repo_choices,
             key=lambda (choice, label): choice.split(':', 1)[1]
         )
     )
     return result
 
 
 @colander.deferred
 def deferred_integration_scopes_validator(node, kw):
     perms = kw.get('permissions')
     def _scope_validator(_node, scope):
         is_super_admin = 'hg.admin' in perms['global']
 
-        if scope in ('global', 'root_repos'):
+        if scope.get('repo'):
+            if (is_super_admin or perms['repositories'].get(
+                scope['repo'].repo_name) == 'repository.admin'):
+                return True
+            msg = _('Only repo admins can create integrations')
+            raise colander.Invalid(_node, msg)
+        elif scope.get('repo_group'):
+            if (is_super_admin or perms['repositories_groups'].get(
+                scope['repo_group'].group_name) == 'group.admin'):
+                return True
+
+            msg = _('Only repogroup admins can create integrations')
+            raise colander.Invalid(_node, msg)
+        else:
             if is_super_admin:
                 return True
             msg = _('Only superadmins can create global integrations')
             raise colander.Invalid(_node, msg)
-        elif isinstance(scope, Repository):
-            if (is_super_admin or perms['repositories'].get(
-                                        scope.repo_name) == 'repository.admin'):
-                return True
-            msg = _('Only repo admins can create integrations')
-            raise colander.Invalid(_node, msg)
-        elif isinstance(scope, RepoGroup):
-            if (is_super_admin or perms['repositories_groups'].get(
-                                            scope.group_name) == 'group.admin'):
-                return True
-
-            msg = _('Only repogroup admins can create integrations')
-            raise colander.Invalid(_node, msg)
-
-        msg = _('Invalid integration scope: %s' % scope)
-        raise colander.Invalid(node, msg)
 
     return _scope_validator
 
 
 @colander.deferred
 def deferred_integration_scopes_widget(node, kw):
     if kw.get('no_scope'):
         return deform.widget.TextInputWidget(readonly=True)
 
     choices = integration_scope_choices(kw.get('permissions'))
     widget = deform.widget.Select2Widget(values=choices)
     return widget
 
-class IntegrationScope(colander.SchemaType):
+
+class IntegrationScopeType(colander.SchemaType):
     def serialize(self, node, appstruct):
         if appstruct is colander.null:
             return colander.null
 
-        if isinstance(appstruct, Repository):
-            return 'repo:%s' % appstruct.repo_name
-        elif isinstance(appstruct, RepoGroup):
-            return 'repogroup:%s' % appstruct.group_name
-        elif appstruct in ('global', 'root_repos'):
-            return appstruct
+        if appstruct.get('repo'):
+            return 'repo:%s' % appstruct['repo'].repo_name
+        elif appstruct.get('repo_group'):
+            if appstruct.get('child_repos_only'):
+                return 'repogroup:%s' % appstruct['repo_group'].group_name
+            else:
+                return 'repogroup-recursive:%s' % (
+                    appstruct['repo_group'].group_name)
+        else:
+            if appstruct.get('child_repos_only'):
+                return 'root-repos'
+            else:
+                return 'global'
+
         raise colander.Invalid(node, '%r is not a valid scope' % appstruct)
 
     def deserialize(self, node, cstruct):
         if cstruct is colander.null:
             return colander.null
 
         if cstruct.startswith('repo:'):
             repo = Repository.get_by_repo_name(cstruct.split(':')[1])
             if repo:
-                return repo
+                return {
+                    'repo': repo,
+                    'repo_group': None,
+                    'child_repos_only': None,
+                }
+        elif cstruct.startswith('repogroup-recursive:'):
+            repo_group = RepoGroup.get_by_group_name(cstruct.split(':')[1])
+            if repo_group:
+                return {
+                    'repo': None,
+                    'repo_group': repo_group,
+                    'child_repos_only': False
+                }
         elif cstruct.startswith('repogroup:'):
             repo_group = RepoGroup.get_by_group_name(cstruct.split(':')[1])
             if repo_group:
-                return repo_group
-        elif cstruct in ('global', 'root_repos'):
-            return cstruct
+                return {
+                    'repo': None,
+                    'repo_group': repo_group,
+                    'child_repos_only': True
+                }
+        elif cstruct == 'global':
+            return {
+                'repo': None,
+                'repo_group': None,
+                'child_repos_only': False
+            }
+        elif cstruct == 'root-repos':
+            return {
+                'repo': None,
+                'repo_group': None,
+                'child_repos_only': True
+            }
 
         raise colander.Invalid(node, '%r is not a valid scope' % cstruct)
 
+
 class IntegrationOptionsSchemaBase(colander.MappingSchema):
 
     name = colander.SchemaNode(
         colander.String(),
         description=_('Short name for this integration.'),
         missing=colander.required,
         title=_('Integration name'),
     )
 
     scope = colander.SchemaNode(
-        IntegrationScope(),
+        IntegrationScopeType(),
         description=_(
-            'Scope of the integration. Group scope means the integration '
-            ' runs on all child repos of that group.'),
+            'Scope of the integration. Recursive means the integration '
+            ' runs on all repos of that group and children recursively.'),
         title=_('Integration scope'),
         validator=deferred_integration_scopes_validator,
         widget=deferred_integration_scopes_widget,
         missing=colander.required,
     )
 
     enabled = colander.SchemaNode(
         colander.Bool(),
         default=True,
         description=_('Enable or disable this integration.'),
         missing=False,
         title=_('Enabled'),
     )
 
 
 
 def make_integration_schema(IntegrationType, settings=None):
     """
     Return a colander schema for an integration type
 
     :param IntegrationType: the integration type class
     :param settings: existing integration settings dict (optional)
     """
 
     settings = settings or {}
     settings_schema = IntegrationType(settings=settings).settings_schema()
 
     class IntegrationSchema(colander.Schema):
         options = IntegrationOptionsSchemaBase()
 
     schema = IntegrationSchema()
     schema['options'].title = _('General integration options')
 
     settings_schema.name = 'settings'
     settings_schema.title = _('{integration_type} settings').format(
         integration_type=IntegrationType.display_name)
     schema.add(settings_schema)
 
     return schema
 
 

rhodecode/templates/admin/integrations/list.html

@@ -1,249 +1,252 b''
 ## -*- coding: utf-8 -*-
 <%inherit file="base.html"/>
 
 <%def name="breadcrumbs_links()">
   %if c.repo:
     ${h.link_to('Settings',h.url('edit_repo', repo_name=c.repo.repo_name))}
   %elif c.repo_group:
     ${h.link_to(_('Admin'),h.url('admin_home'))}
     &raquo;
     ${h.link_to(_('Repository Groups'),h.url('repo_groups'))}
     &raquo;
     ${h.link_to(c.repo_group.group_name,h.url('edit_repo_group', group_name=c.repo_group.group_name))}
   %else:
     ${h.link_to(_('Admin'),h.url('admin_home'))}
     &raquo;
     ${h.link_to(_('Settings'),h.url('admin_settings'))}
   %endif
   %if current_IntegrationType:
     &raquo;
     %if c.repo:
     ${h.link_to(_('Integrations'),
       request.route_url(route_name='repo_integrations_home',
                         repo_name=c.repo.repo_name))}
     %elif c.repo_group:
     ${h.link_to(_('Integrations'),
       request.route_url(route_name='repo_group_integrations_home',
                         repo_group_name=c.repo_group.group_name))}
     %else:
     ${h.link_to(_('Integrations'),
       request.route_url(route_name='global_integrations_home'))}
     %endif
     &raquo;
     ${current_IntegrationType.display_name}
   %else:
     &raquo;
     ${_('Integrations')}
   %endif
 </%def>
 
 <div class="panel panel-default">
   <div class="panel-heading">
     <h3 class="panel-title">
       %if c.repo:
         ${_('Current Integrations for Repository: {repo_name}').format(repo_name=c.repo.repo_name)}
       %elif c.repo_group:
         ${_('Current Integrations for repository group: {repo_group_name}').format(repo_group_name=c.repo_group.group_name)}
       %else:
           ${_('Current Integrations')}
       %endif
       </h3>
   </div>
   <div class="panel-body">
     <%
     if c.repo:
       home_url = request.route_path('repo_integrations_home',
                                     repo_name=c.repo.repo_name)
     elif c.repo_group:
       home_url = request.route_path('repo_group_integrations_home',
                                     repo_group_name=c.repo_group.group_name)
     else:
       home_url = request.route_path('global_integrations_home')
     %>
 
     <a href="${home_url}" class="btn ${not current_IntegrationType and 'btn-primary' or ''}">${_('All')}</a>
 
     %for integration_key, IntegrationType in available_integrations.items():
         <%
         if c.repo:
           list_url = request.route_path('repo_integrations_list',
                                         repo_name=c.repo.repo_name,
                                         integration=integration_key)
         elif c.repo_group:
           list_url = request.route_path('repo_group_integrations_list',
                                         repo_group_name=c.repo_group.group_name,
                                         integration=integration_key)
         else:
           list_url = request.route_path('global_integrations_list',
                                        integration=integration_key)
         %>
       <a href="${list_url}"
          class="btn ${current_IntegrationType and integration_key == current_IntegrationType.key and 'btn-primary' or ''}">
         ${IntegrationType.display_name}
       </a>
     %endfor
 
     <%
     if c.repo:
       create_url = h.route_path('repo_integrations_new', repo_name=c.repo.repo_name)
     elif c.repo_group:
       create_url = h.route_path('repo_group_integrations_new', repo_group_name=c.repo_group.group_name)
     else:
       create_url = h.route_path('global_integrations_new')
     %>
     <p class="pull-right">
       <a href="${create_url}" class="btn btn-small btn-success">${_(u'Create new integration')}</a>
     </p>
 
     <table class="rctable integrations">
       <thead>
         <tr>
             <th><a href="?sort=enabled:${rev_sort_dir}">${_('Enabled')}</a></th>
             <th><a href="?sort=name:${rev_sort_dir}">${_('Name')}</a></th>
             <th colspan="2"><a href="?sort=integration_type:${rev_sort_dir}">${_('Type')}</a></th>
             <th><a href="?sort=scope:${rev_sort_dir}">${_('Scope')}</a></th>
             <th>${_('Actions')}</th>
             <th></th>
         </tr>
       </thead>
       <tbody>
   %if not integrations_list:
         <tr>
           <td colspan="7">
           <% integration_type = current_IntegrationType and current_IntegrationType.display_name or '' %>
             %if c.repo:
               ${_('No {type} integrations for repo {repo} exist yet.').format(type=integration_type, repo=c.repo.repo_name)}
             %elif c.repo_group:
               ${_('No {type} integrations for repogroup {repogroup} exist yet.').format(type=integration_type, repogroup=c.repo_group.group_name)}
             %else:
               ${_('No {type} integrations exist yet.').format(type=integration_type)}
             %endif
 
             %if current_IntegrationType:
             <%
             if c.repo:
               create_url = h.route_path('repo_integrations_create', repo_name=c.repo.repo_name, integration=current_IntegrationType.key)
             elif c.repo_group:
               create_url = h.route_path('repo_group_integrations_create', repo_group_name=c.repo_group.group_name, integration=current_IntegrationType.key)
             else:
               create_url = h.route_path('global_integrations_create', integration=current_IntegrationType.key)
             %>
             %endif
 
             <a href="${create_url}">${_(u'Create one')}</a>
           </td>
         </tr>
   %endif
   %for IntegrationType, integration in integrations_list:
         <tr id="integration_${integration.integration_id}">
           <td class="td-enabled">
             %if integration.enabled:
             <div class="flag_status approved pull-left"></div>
             %else:
             <div class="flag_status rejected pull-left"></div>
             %endif
           </td>
           <td class="td-description">
             ${integration.name}
           </td>
           <td class="td-icon">
             %if integration.integration_type in available_integrations:
             <div class="integration-icon">
               ${available_integrations[integration.integration_type].icon|n}
             </div>
             %else:
               ?
             %endif
           </td>
           <td class="td-type">
             ${integration.integration_type}
           </td>
           <td class="td-scope">
             %if integration.repo:
             <a href="${h.url('summary_home', repo_name=integration.repo.repo_name)}">
               ${_('repo')}:${integration.repo.repo_name}
             </a>
             %elif integration.repo_group:
             <a href="${h.url('repo_group_home', group_name=integration.repo_group.group_name)}">
               ${_('repogroup')}:${integration.repo_group.group_name}
+              %if integration.child_repos_only:
+              ${_('child repos only')}
+              %else:
+              ${_('cascade to all')}
+              %endif
             </a>
             %else:
-              %if integration.scope == 'root_repos':
+              %if integration.child_repos_only:
               ${_('top level repos only')}
-              %elif integration.scope == 'global':
+              %else:
               ${_('global')}
-              %else:
-              ${_('unknown scope')}: ${integration.scope}
               %endif
           </td>
           %endif
           <td class="td-action">
           %if not IntegrationType:
           ${_('unknown integration')}
           %else:
             <%
             if c.repo:
               edit_url = request.route_path('repo_integrations_edit',
                                             repo_name=c.repo.repo_name,
                                             integration=integration.integration_type,
                                             integration_id=integration.integration_id)
             elif c.repo_group:
               edit_url = request.route_path('repo_group_integrations_edit',
                                             repo_group_name=c.repo_group.group_name,
                                             integration=integration.integration_type,
                                             integration_id=integration.integration_id)
             else:
               edit_url = request.route_path('global_integrations_edit',
                                            integration=integration.integration_type,
                                            integration_id=integration.integration_id)
             %>
             <div class="grid_edit">
               <a href="${edit_url}">${_('Edit')}</a>
             </div>
             <div class="grid_delete">
               <a href="${edit_url}"
                  class="btn btn-link btn-danger delete_integration_entry"
                  data-desc="${integration.name}"
                  data-uid="${integration.integration_id}">
                   ${_('Delete')}
               </a>
             </div>
           %endif
           </td>
         </tr>
     %endfor
       <tr id="last-row"></tr>
       </tbody>
     </table>
     <div class="integrations-paginator">
       <div class="pagination-wh pagination-left">
       ${integrations_list.pager('$link_previous ~2~ $link_next')}
       </div>
     </div>
   </div>
 </div>
 <script type="text/javascript">
   var delete_integration = function(entry) {
     if (confirm("Confirm to remove this integration: "+$(entry).data('desc'))) {
       var request = $.ajax({
         type: "POST",
         url: $(entry).attr('href'),
         data: {
           'delete': 'delete',
           'csrf_token': CSRF_TOKEN
         },
         success: function(){
           location.reload();
         },
         error: function(data, textStatus, errorThrown){
           alert("Error while deleting entry.\nError code {0} ({1}). URL: {2}".format(data.status,data.statusText,$(entry)[0].url));
         }
       });
     };
   }
 
   $('.delete_integration_entry').on('click', function(e){
     e.preventDefault();
     delete_integration(this);
   });
 </script>
  No newline at end of file

rhodecode/tests/functional/test_integrations.py

@@ -1,262 +1,264 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  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 webob.exc import HTTPNotFound
 
 import rhodecode
 from rhodecode.model.db import Integration
 from rhodecode.model.meta import Session
 from rhodecode.tests import assert_session_flash, url, TEST_USER_ADMIN_LOGIN
 from rhodecode.tests.utils import AssertResponse
 from rhodecode.integrations import integration_type_registry
 from rhodecode.config.routing import ADMIN_PREFIX
 
 
 @pytest.mark.usefixtures('app', 'autologin_user')
 class TestIntegrationsView(object):
     pass
 
 
 class TestGlobalIntegrationsView(TestIntegrationsView):
     def test_index_no_integrations(self, app):
         url = ADMIN_PREFIX + '/integrations'
         response = app.get(url)
 
         assert response.status_code == 200
         assert 'exist yet' in response.body
 
     def test_index_with_integrations(self, app, global_integration_stub):
         url = ADMIN_PREFIX + '/integrations'
         response = app.get(url)
 
         assert response.status_code == 200
         assert 'exist yet' not in response.body
         assert global_integration_stub.name in response.body
 
     def test_new_integration_page(self, app):
         url = ADMIN_PREFIX + '/integrations/new'
 
         response = app.get(url)
 
         assert response.status_code == 200
 
         for integration_key in integration_type_registry:
             nurl = (ADMIN_PREFIX + '/integrations/{integration}/new').format(
                     integration=integration_key)
             assert nurl in response.body
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_get_create_integration_page(self, app, IntegrationType):
         url = ADMIN_PREFIX + '/integrations/{integration_key}/new'.format(
             integration_key=IntegrationType.key)
 
         response = app.get(url)
 
         assert response.status_code == 200
         assert IntegrationType.display_name in response.body
 
     def test_post_integration_page(self, app, StubIntegrationType, csrf_token,
                                    test_repo_group, backend_random):
         url = ADMIN_PREFIX + '/integrations/{integration_key}/new'.format(
             integration_key=StubIntegrationType.key)
 
         _post_integration_test_helper(app, url, csrf_token, admin_view=True,
             repo=backend_random.repo, repo_group=test_repo_group)
 
 
 class TestRepoGroupIntegrationsView(TestIntegrationsView):
     def test_index_no_integrations(self, app, test_repo_group):
         url = '/{repo_group_name}/settings/integrations'.format(
             repo_group_name=test_repo_group.group_name)
         response = app.get(url)
 
         assert response.status_code == 200
         assert 'exist yet' in response.body
 
     def test_index_with_integrations(self, app, test_repo_group,
                                      repogroup_integration_stub):
         url = '/{repo_group_name}/settings/integrations'.format(
             repo_group_name=test_repo_group.group_name)
 
         stub_name = repogroup_integration_stub.name
         response = app.get(url)
 
         assert response.status_code == 200
         assert 'exist yet' not in response.body
         assert stub_name in response.body
 
     def test_new_integration_page(self, app, test_repo_group):
         repo_group_name = test_repo_group.group_name
         url = '/{repo_group_name}/settings/integrations/new'.format(
             repo_group_name=test_repo_group.group_name)
 
         response = app.get(url)
 
         assert response.status_code == 200
 
         for integration_key in integration_type_registry:
             nurl = ('/{repo_group_name}/settings/integrations'
                     '/{integration}/new').format(
                     repo_group_name=repo_group_name,
                     integration=integration_key)
 
             assert nurl in response.body
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_get_create_integration_page(self, app, test_repo_group,
                                          IntegrationType):
         repo_group_name = test_repo_group.group_name
         url = ('/{repo_group_name}/settings/integrations/{integration_key}/new'
                ).format(repo_group_name=repo_group_name,
                         integration_key=IntegrationType.key)
 
         response = app.get(url)
 
         assert response.status_code == 200
         assert IntegrationType.display_name in response.body
 
     def test_post_integration_page(self, app, test_repo_group, backend_random,
                                    StubIntegrationType, csrf_token):
         repo_group_name = test_repo_group.group_name
         url = ('/{repo_group_name}/settings/integrations/{integration_key}/new'
                ).format(repo_group_name=repo_group_name,
                         integration_key=StubIntegrationType.key)
 
         _post_integration_test_helper(app, url, csrf_token, admin_view=False,
             repo=backend_random.repo, repo_group=test_repo_group)
 
 
 class TestRepoIntegrationsView(TestIntegrationsView):
     def test_index_no_integrations(self, app, backend_random):
         url = '/{repo_name}/settings/integrations'.format(
             repo_name=backend_random.repo.repo_name)
         response = app.get(url)
 
         assert response.status_code == 200
         assert 'exist yet' in response.body
 
     def test_index_with_integrations(self, app, repo_integration_stub):
         url = '/{repo_name}/settings/integrations'.format(
             repo_name=repo_integration_stub.repo.repo_name)
         stub_name = repo_integration_stub.name
 
         response = app.get(url)
 
         assert response.status_code == 200
         assert stub_name in response.body
         assert 'exist yet' not in response.body
 
     def test_new_integration_page(self, app, backend_random):
         repo_name = backend_random.repo.repo_name
         url = '/{repo_name}/settings/integrations/new'.format(
             repo_name=repo_name)
 
         response = app.get(url)
 
         assert response.status_code == 200
 
         for integration_key in integration_type_registry:
             nurl = ('/{repo_name}/settings/integrations'
                     '/{integration}/new').format(
                     repo_name=repo_name,
                     integration=integration_key)
 
             assert nurl in response.body
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_get_create_integration_page(self, app, backend_random,
                                          IntegrationType):
         repo_name = backend_random.repo.repo_name
         url = '/{repo_name}/settings/integrations/{integration_key}/new'.format(
             repo_name=repo_name, integration_key=IntegrationType.key)
 
         response = app.get(url)
 
         assert response.status_code == 200
         assert IntegrationType.display_name in response.body
 
     def test_post_integration_page(self, app, backend_random, test_repo_group,
                                    StubIntegrationType, csrf_token):
         repo_name = backend_random.repo.repo_name
         url = '/{repo_name}/settings/integrations/{integration_key}/new'.format(
             repo_name=repo_name, integration_key=StubIntegrationType.key)
 
         _post_integration_test_helper(app, url, csrf_token, admin_view=False,
             repo=backend_random.repo, repo_group=test_repo_group)
 
 
 def _post_integration_test_helper(app, url, csrf_token, repo, repo_group,
                                   admin_view):
     """
     Posts form data to create integration at the url given then deletes it and
     checks if the redirect url is correct.
     """
 
     app.post(url, params={}, status=403) # missing csrf check
     response = app.post(url, params={'csrf_token': csrf_token})
     assert response.status_code == 200
     assert 'Errors exist' in response.body
 
     scopes_destinations = [
         ('global',
             ADMIN_PREFIX + '/integrations'),
-        ('root_repos',
+        ('root-repos',
                 ADMIN_PREFIX + '/integrations'),
         ('repo:%s' % repo.repo_name,
                 '/%s/settings/integrations' % repo.repo_name),
         ('repogroup:%s' % repo_group.group_name,
                 '/%s/settings/integrations' % repo_group.group_name),
+        ('repogroup-recursive:%s' % repo_group.group_name,
+                '/%s/settings/integrations' % repo_group.group_name),
     ]
 
     for scope, destination in scopes_destinations:
         if admin_view:
             destination = ADMIN_PREFIX + '/integrations'
 
         form_data = [
             ('csrf_token', csrf_token),
             ('__start__', 'options:mapping'),
             ('name', 'test integration'),
             ('scope', scope),
             ('enabled', 'true'),
             ('__end__', 'options:mapping'),
             ('__start__', 'settings:mapping'),
             ('test_int_field', '34'),
             ('test_string_field', ''), # empty value on purpose as it's required
             ('__end__', 'settings:mapping'),
         ]
         errors_response = app.post(url, form_data)
         assert 'Errors exist' in errors_response.body
 
         form_data[-2] = ('test_string_field', 'data!')
         assert Session().query(Integration).count() == 0
         created_response = app.post(url, form_data)
         assert Session().query(Integration).count() == 1
 
         delete_response = app.post(
             created_response.location,
             params={'csrf_token': csrf_token, 'delete': 'delete'})
 
         assert Session().query(Integration).count() == 0
         assert delete_response.location.endswith(destination)

rhodecode/tests/integrations/test_integration.py

@@ -1,192 +1,222 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  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 time
 import pytest
 
 from rhodecode import events
 from rhodecode.tests.fixture import Fixture
 from rhodecode.model.db import Session, Integration
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.integrations.types.base import IntegrationTypeBase
 
 
 class TestDeleteScopesDeletesIntegrations(object):
     def test_delete_repo_with_integration_deletes_integration(self,
         repo_integration_stub):
         Session().delete(repo_integration_stub.repo)
         Session().commit()
         Session().expire_all()
         integration = Integration.get(repo_integration_stub.integration_id)
         assert integration is None
 
 
     def test_delete_repo_group_with_integration_deletes_integration(self,
         repogroup_integration_stub):
         Session().delete(repogroup_integration_stub.repo_group)
         Session().commit()
         Session().expire_all()
         integration = Integration.get(repogroup_integration_stub.integration_id)
         assert integration is None
 
 
 @pytest.fixture
 def integration_repos(request, StubIntegrationType, stub_integration_settings):
     """
     Create repositories and integrations for testing, and destroy them after
+
+    Structure:
+        root_repo
+        parent_group/
+            parent_repo
+            child_group/
+                child_repo
+        other_group/
+            other_repo
     """
     fixture = Fixture()
 
-    repo_group_1_id = 'int_test_repo_group_1_%s' % time.time()
-    repo_group_1 = fixture.create_repo_group(repo_group_1_id)
-    repo_group_2_id = 'int_test_repo_group_2_%s' % time.time()
-    repo_group_2 = fixture.create_repo_group(repo_group_2_id)
+
+    parent_group_id = 'int_test_parent_group_%s' % time.time()
+    parent_group = fixture.create_repo_group(parent_group_id)
+
+    other_group_id = 'int_test_other_group_%s' % time.time()
+    other_group = fixture.create_repo_group(other_group_id)
 
-    repo_1_id = 'int_test_repo_1_%s' % time.time()
-    repo_1 = fixture.create_repo(repo_1_id, repo_group=repo_group_1)
-    repo_2_id = 'int_test_repo_2_%s' % time.time()
-    repo_2 = fixture.create_repo(repo_2_id, repo_group=repo_group_2)
+    child_group_id = (
+        parent_group_id + '/' + 'int_test_child_group_%s' % time.time())
+    child_group = fixture.create_repo_group(child_group_id)
+
+    parent_repo_id = 'int_test_parent_repo_%s' % time.time()
+    parent_repo = fixture.create_repo(parent_repo_id, repo_group=parent_group)
+
+    child_repo_id = 'int_test_child_repo_%s' % time.time()
+    child_repo = fixture.create_repo(child_repo_id, repo_group=child_group)
+
+    other_repo_id = 'int_test_other_repo_%s' % time.time()
+    other_repo = fixture.create_repo(other_repo_id, repo_group=other_group)
 
     root_repo_id = 'int_test_repo_root_%s' % time.time()
     root_repo = fixture.create_repo(root_repo_id)
 
-    integration_global = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings,
-        enabled=True, name='test global integration', scope='global')
-    integration_root_repos = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings,
-        enabled=True, name='test root repos integration', scope='root_repos')
-    integration_repo_1 = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings,
-        enabled=True, name='test repo 1 integration', scope=repo_1)
-    integration_repo_group_1 = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings,
-        enabled=True, name='test repo group 1 integration', scope=repo_group_1)
-    integration_repo_2 = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings,
-        enabled=True, name='test repo 2 integration', scope=repo_2)
-    integration_repo_group_2 = IntegrationModel().create(
-        StubIntegrationType, settings=stub_integration_settings,
-        enabled=True, name='test repo group 2 integration', scope=repo_group_2)
+    integrations = {}
+    for name, repo, repo_group, child_repos_only in [
+            ('global', None, None, None),
+            ('root_repos', None, None, True),
+            ('parent_repo', parent_repo, None, None),
+            ('child_repo', child_repo, None, None),
+            ('other_repo', other_repo, None, None),
+            ('root_repo', root_repo, None, None),
+            ('parent_group', None, parent_group, True),
+            ('parent_group_recursive', None, parent_group, False),
+            ('child_group', None, child_group, True),
+            ('child_group_recursive', None, child_group, False),
+            ('other_group', None, other_group, True),
+            ('other_group_recursive', None, other_group, False),
+        ]:
+        integrations[name] = IntegrationModel().create(
+            StubIntegrationType, settings=stub_integration_settings,
+            enabled=True, name='test %s integration' % name,
+            repo=repo, repo_group=repo_group, child_repos_only=child_repos_only)
 
     Session().commit()
 
     def _cleanup():
-        Session().delete(integration_global)
-        Session().delete(integration_root_repos)
-        Session().delete(integration_repo_1)
-        Session().delete(integration_repo_group_1)
-        Session().delete(integration_repo_2)
-        Session().delete(integration_repo_group_2)
+        for integration in integrations.values():
+            Session.delete(integration)
+
         fixture.destroy_repo(root_repo)
-        fixture.destroy_repo(repo_1)
-        fixture.destroy_repo(repo_2)
-        fixture.destroy_repo_group(repo_group_1)
-        fixture.destroy_repo_group(repo_group_2)
+        fixture.destroy_repo(child_repo)
+        fixture.destroy_repo(parent_repo)
+        fixture.destroy_repo(other_repo)
+        fixture.destroy_repo_group(child_group)
+        fixture.destroy_repo_group(parent_group)
+        fixture.destroy_repo_group(other_group)
 
     request.addfinalizer(_cleanup)
 
     return {
+        'integrations': integrations,
         'repos': {
-            'repo_1': repo_1,
-            'repo_2': repo_2,
             'root_repo': root_repo,
-        },
-        'repo_groups': {
-            'repo_group_1': repo_group_1,
-            'repo_group_2': repo_group_2,
-        },
-        'integrations': {
-            'global': integration_global,
-            'root_repos': integration_root_repos,
-            'repo_1': integration_repo_1,
-            'repo_2': integration_repo_2,
-            'repo_group_1': integration_repo_group_1,
-            'repo_group_2': integration_repo_group_2,
+            'other_repo': other_repo,
+            'parent_repo': parent_repo,
+                'child_repo': child_repo,
         }
     }
 
 
 def test_enabled_integration_repo_scopes(integration_repos):
     integrations = integration_repos['integrations']
     repos = integration_repos['repos']
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['root_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
-        integrations['root_repos']
+        integrations['root_repos'],
+        integrations['root_repo'],
+    ]
+
+
+    triggered_integrations = IntegrationModel().get_for_event(
+        events.RepoEvent(repos['other_repo']))
+
+    assert triggered_integrations == [
+        integrations['global'],
+        integrations['other_repo'],
+        integrations['other_group'],
+        integrations['other_group_recursive'],
     ]
 
 
     triggered_integrations = IntegrationModel().get_for_event(
-        events.RepoEvent(repos['repo_1']))
+        events.RepoEvent(repos['parent_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
-        integrations['repo_1'],
-        integrations['repo_group_1']
+        integrations['parent_repo'],
+        integrations['parent_group'],
+        integrations['parent_group_recursive'],
     ]
 
-
     triggered_integrations = IntegrationModel().get_for_event(
-        events.RepoEvent(repos['repo_2']))
+        events.RepoEvent(repos['child_repo']))
 
     assert triggered_integrations == [
         integrations['global'],
-        integrations['repo_2'],
-        integrations['repo_group_2'],
+        integrations['child_repo'],
+        integrations['parent_group_recursive'],
+        integrations['child_group'],
+        integrations['child_group_recursive'],
     ]
 
 
 def test_disabled_integration_repo_scopes(integration_repos):
     integrations = integration_repos['integrations']
     repos = integration_repos['repos']
 
     for integration in integrations.values():
         integration.enabled = False
     Session().commit()
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.RepoEvent(repos['root_repo']))
 
     assert triggered_integrations == []
 
 
     triggered_integrations = IntegrationModel().get_for_event(
-        events.RepoEvent(repos['repo_1']))
+        events.RepoEvent(repos['parent_repo']))
 
     assert triggered_integrations == []
 
 
     triggered_integrations = IntegrationModel().get_for_event(
-        events.RepoEvent(repos['repo_2']))
+        events.RepoEvent(repos['child_repo']))
 
     assert triggered_integrations == []
 
 
+    triggered_integrations = IntegrationModel().get_for_event(
+        events.RepoEvent(repos['other_repo']))
+
+    assert triggered_integrations == []
+
+
+
 def test_enabled_non_repo_integrations(integration_repos):
     integrations = integration_repos['integrations']
 
     triggered_integrations = IntegrationModel().get_for_event(
         events.UserPreCreate({}))
 
     assert triggered_integrations == [integrations['global']]

rhodecode/tests/models/schemas/test_integration_schema.py

@@ -1,120 +1,171 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2016-2016  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 colander
 import pytest
 
 from rhodecode.model import validation_schema
 
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 from rhodecode.model.validation_schema.schemas.integration_schema import (
     make_integration_schema
 )
 
 
 @pytest.mark.usefixtures('app', 'autologin_user')
 class TestIntegrationSchema(object):
 
     def test_deserialize_integration_schema_perms(self, backend_random,
                                                   test_repo_group,
                                                   StubIntegrationType):
 
         repo = backend_random.repo
         repo_group = test_repo_group
 
 
         empty_perms_dict = {
             'global': [],
             'repositories': {},
             'repositories_groups': {},
         }
 
-        perms_tests = {
-            ('repo:%s' % repo.repo_name, repo): [
-                ({},  False),
-                ({'global': ['hg.admin']},  True),
-                ({'global': []},  False),
-                ({'repositories': {repo.repo_name: 'repository.admin'}}, True),
-                ({'repositories': {repo.repo_name: 'repository.read'}}, False),
-                ({'repositories': {repo.repo_name: 'repository.write'}}, False),
-                ({'repositories': {repo.repo_name: 'repository.none'}}, False),
-            ],
-            ('repogroup:%s' % repo_group.group_name, repo_group): [
-                ({},  False),
-                ({'global': ['hg.admin']},  True),
-                ({'global': []},  False),
-                ({'repositories_groups':
-                    {repo_group.group_name: 'group.admin'}}, True),
-                ({'repositories_groups':
-                    {repo_group.group_name: 'group.read'}}, False),
-                ({'repositories_groups':
-                    {repo_group.group_name: 'group.write'}}, False),
-                ({'repositories_groups':
-                    {repo_group.group_name: 'group.none'}}, False),
-            ],
-            ('global', 'global'): [
-                ({},  False),
-                ({'global': ['hg.admin']},  True),
-                ({'global': []},  False),
-            ],
-            ('root_repos', 'root_repos'): [
-                ({},  False),
-                ({'global': ['hg.admin']},  True),
-                ({'global': []},  False),
-            ],
-        }
+        perms_tests = [
+            (
+                'repo:%s' % repo.repo_name,
+                {
+                    'child_repos_only': None,
+                    'repo_group': None,
+                    'repo': repo,
+                },
+                [
+                    ({},  False),
+                    ({'global': ['hg.admin']},  True),
+                    ({'global': []},  False),
+                    ({'repositories': {repo.repo_name: 'repository.admin'}}, True),
+                    ({'repositories': {repo.repo_name: 'repository.read'}}, False),
+                    ({'repositories': {repo.repo_name: 'repository.write'}}, False),
+                    ({'repositories': {repo.repo_name: 'repository.none'}}, False),
+                ]
+            ),
+            (
+                'repogroup:%s' % repo_group.group_name,
+                {
+                    'repo': None,
+                    'repo_group': repo_group,
+                    'child_repos_only': True,
+                },
+                [
+                    ({},  False),
+                    ({'global': ['hg.admin']},  True),
+                    ({'global': []},  False),
+                    ({'repositories_groups':
+                        {repo_group.group_name: 'group.admin'}}, True),
+                    ({'repositories_groups':
+                        {repo_group.group_name: 'group.read'}}, False),
+                    ({'repositories_groups':
+                        {repo_group.group_name: 'group.write'}}, False),
+                    ({'repositories_groups':
+                        {repo_group.group_name: 'group.none'}}, False),
+                ]
+            ),
+            (
+                'repogroup-recursive:%s' % repo_group.group_name,
+                {
+                    'repo': None,
+                    'repo_group': repo_group,
+                    'child_repos_only': False,
+                },
+                [
+                    ({},  False),
+                    ({'global': ['hg.admin']},  True),
+                    ({'global': []},  False),
+                    ({'repositories_groups':
+                        {repo_group.group_name: 'group.admin'}}, True),
+                    ({'repositories_groups':
+                        {repo_group.group_name: 'group.read'}}, False),
+                    ({'repositories_groups':
+                        {repo_group.group_name: 'group.write'}}, False),
+                    ({'repositories_groups':
+                        {repo_group.group_name: 'group.none'}}, False),
+                ]
+            ),
+            (
+                'global',
+                {
+                    'repo': None,
+                    'repo_group': None,
+                    'child_repos_only': False,
+                }, [
+                    ({},  False),
+                    ({'global': ['hg.admin']},  True),
+                    ({'global': []},  False),
+                ]
+            ),
+            (
+                'root-repos',
+                {
+                    'repo': None,
+                    'repo_group': None,
+                    'child_repos_only': True,
+                }, [
+                    ({},  False),
+                    ({'global': ['hg.admin']},  True),
+                    ({'global': []},  False),
+                ]
+            ),
+        ]
 
-        for (scope_input, scope_output), perms_allowed in perms_tests.items():
+        for scope_input, scope_output, perms_allowed in perms_tests:
             for perms_update, allowed in perms_allowed:
                 perms = dict(empty_perms_dict, **perms_update)
 
                 schema = make_integration_schema(
                     IntegrationType=StubIntegrationType
                 ).bind(permissions=perms)
 
                 input_data = {
                     'options': {
                         'enabled': 'true',
                         'scope': scope_input,
                         'name': 'test integration',
                     },
                     'settings': {
                         'test_string_field': 'stringy',
                         'test_int_field': '100',
                     }
                 }
 
                 if not allowed:
                     with pytest.raises(colander.Invalid):
                         schema.deserialize(input_data)
                 else:
                     assert schema.deserialize(input_data) == {
                         'options': {
                             'enabled': True,
                             'scope': scope_output,
                             'name': 'test integration',
                         },
                         'settings': {
                             'test_string_field': 'stringy',
                             'test_int_field': 100,
                         }
                     }
 

rhodecode/tests/plugin.py

@@ -1,1760 +1,1779 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2016  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 datetime
 import hashlib
 import os
 import re
 import pprint
 import shutil
 import socket
 import subprocess
 import time
 import uuid
 
 import mock
 import pyramid.testing
 import pytest
 import colander
 import requests
 from webtest.app import TestApp
 
 import rhodecode
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import ChangesetCommentsModel
 from rhodecode.model.db import (
     PullRequest, Repository, RhodeCodeSetting, ChangesetStatus, RepoGroup,
     UserGroup, RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi, Integration)
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.settings import VcsSettingsModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 from rhodecode.lib.utils import repo2db_mapper
 from rhodecode.lib.vcs import create_vcsserver_proxy
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.tests import (
     login_user_session, get_new_dir, utils, TESTS_TMP_PATH,
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR2_LOGIN,
     TEST_USER_REGULAR_PASS)
 from rhodecode.tests.fixture import Fixture
 
 
 def _split_comma(value):
     return value.split(',')
 
 
 def pytest_addoption(parser):
     parser.addoption(
         '--keep-tmp-path', action='store_true',
         help="Keep the test temporary directories")
     parser.addoption(
         '--backends', action='store', type=_split_comma,
         default=['git', 'hg', 'svn'],
         help="Select which backends to test for backend specific tests.")
     parser.addoption(
         '--dbs', action='store', type=_split_comma,
         default=['sqlite'],
         help="Select which database to test for database specific tests. "
              "Possible options are sqlite,postgres,mysql")
     parser.addoption(
         '--appenlight', '--ae', action='store_true',
         help="Track statistics in appenlight.")
     parser.addoption(
         '--appenlight-api-key', '--ae-key',
         help="API key for Appenlight.")
     parser.addoption(
         '--appenlight-url', '--ae-url',
         default="https://ae.rhodecode.com",
         help="Appenlight service URL, defaults to https://ae.rhodecode.com")
     parser.addoption(
         '--sqlite-connection-string', action='store',
         default='', help="Connection string for the dbs tests with SQLite")
     parser.addoption(
         '--postgres-connection-string', action='store',
         default='', help="Connection string for the dbs tests with Postgres")
     parser.addoption(
         '--mysql-connection-string', action='store',
         default='', help="Connection string for the dbs tests with MySQL")
     parser.addoption(
         '--repeat', type=int, default=100,
         help="Number of repetitions in performance tests.")
 
 
 def pytest_configure(config):
     # Appy the kombu patch early on, needed for test discovery on Python 2.7.11
     from rhodecode.config import patches
     patches.kombu_1_5_1_python_2_7_11()
 
 
 def pytest_collection_modifyitems(session, config, items):
     # nottest marked, compare nose, used for transition from nose to pytest
     remaining = [
         i for i in items if getattr(i.obj, '__test__', True)]
     items[:] = remaining
 
 
 def pytest_generate_tests(metafunc):
     # Support test generation based on --backend parameter
     if 'backend_alias' in metafunc.fixturenames:
         backends = get_backends_from_metafunc(metafunc)
         scope = None
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
         metafunc.parametrize('backend_alias', backends, scope=scope)
     elif hasattr(metafunc.function, 'backends'):
         backends = get_backends_from_metafunc(metafunc)
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
 
 
 def get_backends_from_metafunc(metafunc):
     requested_backends = set(metafunc.config.getoption('--backends'))
     if hasattr(metafunc.function, 'backends'):
         # Supported backends by this test function, created from
         # pytest.mark.backends
         backends = metafunc.function.backends.args
     elif hasattr(metafunc.cls, 'backend_alias'):
         # Support class attribute "backend_alias", this is mainly
         # for legacy reasons for tests not yet using pytest.mark.backends
         backends = [metafunc.cls.backend_alias]
     else:
         backends = metafunc.config.getoption('--backends')
     return requested_backends.intersection(backends)
 
 
 @pytest.fixture(scope='session', autouse=True)
 def activate_example_rcextensions(request):
     """
     Patch in an example rcextensions module which verifies passed in kwargs.
     """
     from rhodecode.tests.other import example_rcextensions
 
     old_extensions = rhodecode.EXTENSIONS
     rhodecode.EXTENSIONS = example_rcextensions
 
     @request.addfinalizer
     def cleanup():
         rhodecode.EXTENSIONS = old_extensions
 
 
 @pytest.fixture
 def capture_rcextensions():
     """
     Returns the recorded calls to entry points in rcextensions.
     """
     calls = rhodecode.EXTENSIONS.calls
     calls.clear()
     # Note: At this moment, it is still the empty dict, but that will
     # be filled during the test run and since it is a reference this
     # is enough to make it work.
     return calls
 
 
 @pytest.fixture(scope='session')
 def http_environ_session():
     """
     Allow to use "http_environ" in session scope.
     """
     return http_environ(
         http_host_stub=http_host_stub())
 
 
 @pytest.fixture
 def http_host_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return 'test.example.com:80'
 
 
 @pytest.fixture
 def http_environ(http_host_stub):
     """
     HTTP extra environ keys.
 
     User by the test application and as well for setting up the pylons
     environment. In the case of the fixture "app" it should be possible
     to override this for a specific test case.
     """
     return {
         'SERVER_NAME': http_host_stub.split(':')[0],
         'SERVER_PORT': http_host_stub.split(':')[1],
         'HTTP_HOST': http_host_stub,
     }
 
 
 @pytest.fixture(scope='function')
 def app(request, pylonsapp, http_environ):
     app = TestApp(
         pylonsapp,
         extra_environ=http_environ)
     if request.cls:
         request.cls.app = app
     return app
 
 
 @pytest.fixture()
 def app_settings(pylonsapp, pylons_config):
     """
     Settings dictionary used to create the app.
 
     Parses the ini file and passes the result through the sanitize and apply
     defaults mechanism in `rhodecode.config.middleware`.
     """
     from paste.deploy.loadwsgi import loadcontext, APP
     from rhodecode.config.middleware import (
         sanitize_settings_and_apply_defaults)
     context = loadcontext(APP, 'config:' + pylons_config)
     settings = sanitize_settings_and_apply_defaults(context.config())
     return settings
 
 
 LoginData = collections.namedtuple('LoginData', ('csrf_token', 'user'))
 
 
 def _autologin_user(app, *args):
     session = login_user_session(app, *args)
     csrf_token = rhodecode.lib.auth.get_csrf_token(session)
     return LoginData(csrf_token, session['rhodecode_user'])
 
 
 @pytest.fixture
 def autologin_user(app):
     """
     Utility fixture which makes sure that the admin user is logged in
     """
     return _autologin_user(app)
 
 
 @pytest.fixture
 def autologin_regular_user(app):
     """
     Utility fixture which makes sure that the regular user is logged in
     """
     return _autologin_user(
         app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 
 
 @pytest.fixture(scope='function')
 def csrf_token(request, autologin_user):
     return autologin_user.csrf_token
 
 
 @pytest.fixture(scope='function')
 def xhr_header(request):
     return {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
 
 
 @pytest.fixture
 def real_crypto_backend(monkeypatch):
     """
     Switch the production crypto backend on for this test.
 
     During the test run the crypto backend is replaced with a faster
     implementation based on the MD5 algorithm.
     """
     monkeypatch.setattr(rhodecode, 'is_test', False)
 
 
 @pytest.fixture(scope='class')
 def index_location(request, pylonsapp):
     index_location = pylonsapp.config['app_conf']['search.location']
     if request.cls:
         request.cls.index_location = index_location
     return index_location
 
 
 @pytest.fixture(scope='session', autouse=True)
 def tests_tmp_path(request):
     """
     Create temporary directory to be used during the test session.
     """
     if not os.path.exists(TESTS_TMP_PATH):
         os.makedirs(TESTS_TMP_PATH)
 
     if not request.config.getoption('--keep-tmp-path'):
         @request.addfinalizer
         def remove_tmp_path():
             shutil.rmtree(TESTS_TMP_PATH)
 
     return TESTS_TMP_PATH
 
 
 @pytest.fixture(scope='session', autouse=True)
 def patch_pyro_request_scope_proxy_factory(request):
     """
     Patch the pyro proxy factory to always use the same dummy request object
     when under test. This will return the same pyro proxy on every call.
     """
     dummy_request = pyramid.testing.DummyRequest()
 
     def mocked_call(self, request=None):
         return self.getProxy(request=dummy_request)
 
     patcher = mock.patch(
         'rhodecode.lib.vcs.client.RequestScopeProxyFactory.__call__',
         new=mocked_call)
     patcher.start()
 
     @request.addfinalizer
     def undo_patching():
         patcher.stop()
 
 
 @pytest.fixture
 def test_repo_group(request):
     """
     Create a temporary repository group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     repogroupid = 'test_repo_group_%s' % int(time.time())
     repo_group = fixture.create_repo_group(repogroupid)
 
     def _cleanup():
         fixture.destroy_repo_group(repogroupid)
 
     request.addfinalizer(_cleanup)
     return repo_group
 
 
 @pytest.fixture
 def test_user_group(request):
     """
     Create a temporary user group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     usergroupid = 'test_user_group_%s' % int(time.time())
     user_group = fixture.create_user_group(usergroupid)
 
     def _cleanup():
         fixture.destroy_user_group(user_group)
 
     request.addfinalizer(_cleanup)
     return user_group
 
 
 @pytest.fixture(scope='session')
 def test_repo(request):
     container = TestRepoContainer()
     request.addfinalizer(container._cleanup)
     return container
 
 
 class TestRepoContainer(object):
     """
     Container for test repositories which are used read only.
 
     Repositories will be created on demand and re-used during the lifetime
     of this object.
 
     Usage to get the svn test repository "minimal"::
 
        test_repo = TestContainer()
        repo = test_repo('minimal', 'svn')
 
     """
 
     dump_extractors = {
         'git': utils.extract_git_repo_from_dump,
         'hg': utils.extract_hg_repo_from_dump,
         'svn': utils.extract_svn_repo_from_dump,
     }
 
     def __init__(self):
         self._cleanup_repos = []
         self._fixture = Fixture()
         self._repos = {}
 
     def __call__(self, dump_name, backend_alias):
         key = (dump_name, backend_alias)
         if key not in self._repos:
             repo = self._create_repo(dump_name, backend_alias)
             self._repos[key] = repo.repo_id
         return Repository.get(self._repos[key])
 
     def _create_repo(self, dump_name, backend_alias):
         repo_name = '%s-%s' % (backend_alias, dump_name)
         backend_class = get_backend(backend_alias)
         dump_extractor = self.dump_extractors[backend_alias]
         repo_path = dump_extractor(dump_name, repo_name)
         vcs_repo = backend_class(repo_path)
         repo2db_mapper({repo_name: vcs_repo})
         repo = RepoModel().get_by_repo_name(repo_name)
         self._cleanup_repos.append(repo_name)
         return repo
 
     def _cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
 
 @pytest.fixture
 def backend(request, backend_alias, pylonsapp, test_repo):
     """
     Parametrized fixture which represents a single backend implementation.
 
     It respects the option `--backends` to focus the test run on specific
     backend implementations.
 
     It also supports `pytest.mark.xfail_backends` to mark tests as failing
     for specific backends. This is intended as a utility for incremental
     development of a new backend implementation.
     """
     if backend_alias not in request.config.getoption('--backends'):
         pytest.skip("Backend %s not selected." % (backend_alias, ))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = 'vcs_test_%s' % (backend_alias, )
     backend = Backend(
         alias=backend_alias,
         repo_name=repo_name,
         test_name=request.node.name,
         test_repo_container=test_repo)
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture
 def backend_git(request, pylonsapp, test_repo):
     return backend(request, 'git', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_hg(request, pylonsapp, test_repo):
     return backend(request, 'hg', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_svn(request, pylonsapp, test_repo):
     return backend(request, 'svn', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_random(backend_git):
     """
     Use this to express that your tests need "a backend.
 
     A few of our tests need a backend, so that we can run the code. This
     fixture is intended to be used for such cases. It will pick one of the
     backends and run the tests.
 
     The fixture `backend` would run the test multiple times for each
     available backend which is a pure waste of time if the test is
     independent of the backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return backend_git
 
 
 @pytest.fixture
 def backend_stub(backend_git):
     """
     Use this to express that your tests need a backend stub
 
     TODO: mikhail: Implement a real stub logic instead of returning
     a git backend
     """
     return backend_git
 
 
 @pytest.fixture
 def repo_stub(backend_stub):
     """
     Use this to express that your tests need a repository stub
     """
     return backend_stub.create_repo()
 
 
 class Backend(object):
     """
     Represents the test configuration for one supported backend
 
     Provides easy access to different test repositories based on
     `__getitem__`. Such repositories will only be created once per test
     session.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
     _master_repo = None
     _commit_ids = {}
 
     def __init__(self, alias, repo_name, test_name, test_repo_container):
         self.alias = alias
         self.repo_name = repo_name
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
         # TODO: johbo: Used as a delegate interim. Not yet sure if Backend or
         # Fixture will survive in the end.
         self._fixture = Fixture()
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias)
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo or the
         last repo which has been created with `create_repo`.
         """
         from rhodecode.model.db import Repository
         return Repository.get_by_repo_name(self.repo_name)
 
     @property
     def default_branch_name(self):
         VcsRepository = get_backend(self.alias)
         return VcsRepository.DEFAULT_BRANCH_NAME
 
     @property
     def default_head_id(self):
         """
         Returns the default head id of the underlying backend.
 
         This will be the default branch name in case the backend does have a
         default branch. In the other cases it will point to a valid head
         which can serve as the base to create a new commit on top of it.
         """
         vcsrepo = self.repo.scm_instance()
         head_id = (
             vcsrepo.DEFAULT_BRANCH_NAME or
             vcsrepo.commit_ids[-1])
         return head_id
 
     @property
     def commit_ids(self):
         """
         Returns the list of commits for the last created repository
         """
         return self._commit_ids
 
     def create_master_repo(self, commits):
         """
         Create a repository and remember it as a template.
 
         This allows to easily create derived repositories to construct
         more complex scenarios for diff, compare and pull requests.
 
         Returns a commit map which maps from commit message to raw_id.
         """
         self._master_repo = self.create_repo(commits=commits)
         return self._commit_ids
 
     def create_repo(
             self, commits=None, number_of_commits=0, heads=None,
             name_suffix=u'', **kwargs):
         """
         Create a repository and record it for later cleanup.
 
         :param commits: Optional. A sequence of dict instances.
            Will add a commit per entry to the new repository.
         :param number_of_commits: Optional. If set to a number, this number of
            commits will be added to the new repository.
         :param heads: Optional. Can be set to a sequence of of commit
            names which shall be pulled in from the master repository.
 
         """
         self.repo_name = self._next_repo_name() + name_suffix
         repo = self._fixture.create_repo(
             self.repo_name, repo_type=self.alias, **kwargs)
         self._cleanup_repos.append(repo.repo_name)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, self.repo_name)}
             for x in xrange(number_of_commits)]
         self._add_commits_to_repo(repo.scm_instance(), commits)
         if heads:
             self.pull_heads(repo, heads)
 
         return repo
 
     def pull_heads(self, repo, heads):
         """
         Make sure that repo contains all commits mentioned in `heads`
         """
         vcsmaster = self._master_repo.scm_instance()
         vcsrepo = repo.scm_instance()
         vcsrepo.config.clear_section('hooks')
         commit_ids = [self._commit_ids[h] for h in heads]
         vcsrepo.pull(vcsmaster.path, commit_ids=commit_ids)
 
     def create_fork(self):
         repo_to_fork = self.repo_name
         self.repo_name = self._next_repo_name()
         repo = self._fixture.create_fork(repo_to_fork, self.repo_name)
         self._cleanup_repos.append(self.repo_name)
         return repo
 
     def new_repo_name(self, suffix=u''):
         self.repo_name = self._next_repo_name() + suffix
         self._cleanup_repos.append(self.repo_name)
         return self.repo_name
 
     def _next_repo_name(self):
         return u"%s_%s" % (
             self.invalid_repo_name.sub(u'_', self._test_name),
             len(self._cleanup_repos))
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         commits = [
             {'added': [
                 FileNode(filename, content=content),
             ]},
         ]
         self._add_commits_to_repo(self.repo.scm_instance(), commits)
 
     def enable_downloads(self):
         repo = self.repo
         repo.enable_downloads = True
         Session().add(repo)
         Session().commit()
 
     def cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
     def _add_commits_to_repo(self, repo, commits):
         commit_ids = _add_commits_to_repo(repo, commits)
         if not commit_ids:
             return
         self._commit_ids = commit_ids
 
         # Creating refs for Git to allow fetching them from remote repository
         if self.alias == 'git':
             refs = {}
             for message in self._commit_ids:
                 # TODO: mikhail: do more special chars replacements
                 ref_name = 'refs/test-refs/{}'.format(
                     message.replace(' ', ''))
                 refs[ref_name] = self._commit_ids[message]
             self._create_refs(repo, refs)
 
     def _create_refs(self, repo, refs):
         for ref_name in refs:
             repo.set_refs(ref_name, refs[ref_name])
 
 
 @pytest.fixture
 def vcsbackend(request, backend_alias, tests_tmp_path, pylonsapp, test_repo):
     """
     Parametrized fixture which represents a single vcs backend implementation.
 
     See the fixture `backend` for more details. This one implements the same
     concept, but on vcs level. So it does not provide model instances etc.
 
     Parameters are generated dynamically, see :func:`pytest_generate_tests`
     for how this works.
     """
     if backend_alias not in request.config.getoption('--backends'):
         pytest.skip("Backend %s not selected." % (backend_alias, ))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = 'vcs_test_%s' % (backend_alias, )
     repo_path = os.path.join(tests_tmp_path, repo_name)
     backend = VcsBackend(
         alias=backend_alias,
         repo_path=repo_path,
         test_name=request.node.name,
         test_repo_container=test_repo)
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture
 def vcsbackend_git(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'git', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_hg(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'hg', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_svn(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'svn', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_random(vcsbackend_git):
     """
     Use this to express that your tests need "a vcsbackend".
 
     The fixture `vcsbackend` would run the test multiple times for each
     available vcs backend which is a pure waste of time if the test is
     independent of the vcs backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return vcsbackend_git
 
 
 @pytest.fixture
 def vcsbackend_stub(vcsbackend_git):
     """
     Use this to express that your test just needs a stub of a vcsbackend.
 
     Plan is to eventually implement an in-memory stub to speed tests up.
     """
     return vcsbackend_git
 
 
 class VcsBackend(object):
     """
     Represents the test configuration for one supported vcs backend.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
 
     def __init__(self, alias, repo_path, test_name, test_repo_container):
         self.alias = alias
         self._repo_path = repo_path
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias).scm_instance()
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo of the last
         repo which has been created.
         """
         Repository = get_backend(self.alias)
         return Repository(self._repo_path)
 
     @property
     def backend(self):
         """
         Returns the backend implementation class.
         """
         return get_backend(self.alias)
 
     def create_repo(self, commits=None, number_of_commits=0, _clone_repo=None):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         repo_class = get_backend(self.alias)
         src_url = None
         if _clone_repo:
             src_url = _clone_repo.path
         repo = repo_class(self._repo_path, create=True, src_url=src_url)
         self._cleanup_repos.append(repo)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, repo_name)}
             for x in xrange(number_of_commits)]
         _add_commits_to_repo(repo, commits)
         return repo
 
     def clone_repo(self, repo):
         return self.create_repo(_clone_repo=repo)
 
     def cleanup(self):
         for repo in self._cleanup_repos:
             shutil.rmtree(repo.path)
 
     def new_repo_path(self):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         return self._repo_path
 
     def _next_repo_name(self):
         return "%s_%s" % (
             self.invalid_repo_name.sub('_', self._test_name),
             len(self._cleanup_repos))
 
     def add_file(self, repo, filename, content='Test content\n'):
         imc = repo.in_memory_commit
         imc.add(FileNode(filename, content=content))
         imc.commit(
             message=u'Automatic commit from vcsbackend fixture',
             author=u'Automatic')
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         self.add_file(self.repo, filename, content)
 
 
 def _add_commits_to_repo(vcs_repo, commits):
     commit_ids = {}
     if not commits:
         return commit_ids
 
     imc = vcs_repo.in_memory_commit
     commit = None
 
     for idx, commit in enumerate(commits):
         message = unicode(commit.get('message', 'Commit %s' % idx))
 
         for node in commit.get('added', []):
             imc.add(FileNode(node.path, content=node.content))
         for node in commit.get('changed', []):
             imc.change(FileNode(node.path, content=node.content))
         for node in commit.get('removed', []):
             imc.remove(FileNode(node.path))
 
         parents = [
             vcs_repo.get_commit(commit_id=commit_ids[p])
             for p in commit.get('parents', [])]
 
         operations = ('added', 'changed', 'removed')
         if not any((commit.get(o) for o in operations)):
             imc.add(FileNode('file_%s' % idx, content=message))
 
         commit = imc.commit(
             message=message,
             author=unicode(commit.get('author', 'Automatic')),
             date=commit.get('date'),
             branch=commit.get('branch'),
             parents=parents)
 
         commit_ids[commit.message] = commit.raw_id
 
     return commit_ids
 
 
 @pytest.fixture
 def reposerver(request):
     """
     Allows to serve a backend repository
     """
 
     repo_server = RepoServer()
     request.addfinalizer(repo_server.cleanup)
     return repo_server
 
 
 class RepoServer(object):
     """
     Utility to serve a local repository for the duration of a test case.
 
     Supports only Subversion so far.
     """
 
     url = None
 
     def __init__(self):
         self._cleanup_servers = []
 
     def serve(self, vcsrepo):
         if vcsrepo.alias != 'svn':
             raise TypeError("Backend %s not supported" % vcsrepo.alias)
 
         proc = subprocess.Popen(
             ['svnserve', '-d', '--foreground', '--listen-host', 'localhost',
              '--root', vcsrepo.path])
         self._cleanup_servers.append(proc)
         self.url = 'svn://localhost'
 
     def cleanup(self):
         for proc in self._cleanup_servers:
             proc.terminate()
 
 
 @pytest.fixture
 def pr_util(backend, request):
     """
     Utility for tests of models and for functional tests around pull requests.
 
     It gives an instance of :class:`PRTestUtility` which provides various
     utility methods around one pull request.
 
     This fixture uses `backend` and inherits its parameterization.
     """
 
     util = PRTestUtility(backend)
 
     @request.addfinalizer
     def cleanup():
         util.cleanup()
 
     return util
 
 
 class PRTestUtility(object):
 
     pull_request = None
     pull_request_id = None
     mergeable_patcher = None
     mergeable_mock = None
     notification_patcher = None
 
     def __init__(self, backend):
         self.backend = backend
 
     def create_pull_request(
             self, commits=None, target_head=None, source_head=None,
             revisions=None, approved=False, author=None, mergeable=False,
             enable_notifications=True, name_suffix=u'', reviewers=None,
             title=u"Test", description=u"Description"):
         self.set_mergeable(mergeable)
         if not enable_notifications:
             # mock notification side effect
             self.notification_patcher = mock.patch(
                 'rhodecode.model.notification.NotificationModel.create')
             self.notification_patcher.start()
 
         if not self.pull_request:
             if not commits:
                 commits = [
                     {'message': 'c1'},
                     {'message': 'c2'},
                     {'message': 'c3'},
                 ]
                 target_head = 'c1'
                 source_head = 'c2'
                 revisions = ['c2']
 
             self.commit_ids = self.backend.create_master_repo(commits)
             self.target_repository = self.backend.create_repo(
                 heads=[target_head], name_suffix=name_suffix)
             self.source_repository = self.backend.create_repo(
                 heads=[source_head], name_suffix=name_suffix)
             self.author = author or UserModel().get_by_username(
                 TEST_USER_ADMIN_LOGIN)
 
             model = PullRequestModel()
             self.create_parameters = {
                 'created_by': self.author,
                 'source_repo': self.source_repository.repo_name,
                 'source_ref': self._default_branch_reference(source_head),
                 'target_repo': self.target_repository.repo_name,
                 'target_ref': self._default_branch_reference(target_head),
                 'revisions': [self.commit_ids[r] for r in revisions],
                 'reviewers': reviewers or self._get_reviewers(),
                 'title': title,
                 'description': description,
             }
             self.pull_request = model.create(**self.create_parameters)
             assert model.get_versions(self.pull_request) == []
 
             self.pull_request_id = self.pull_request.pull_request_id
 
             if approved:
                 self.approve()
 
             Session().add(self.pull_request)
             Session().commit()
 
         return self.pull_request
 
     def approve(self):
         self.create_status_votes(
             ChangesetStatus.STATUS_APPROVED,
             *self.pull_request.reviewers)
 
     def close(self):
         PullRequestModel().close_pull_request(self.pull_request, self.author)
 
     def _default_branch_reference(self, commit_message):
         reference = '%s:%s:%s' % (
             'branch',
             self.backend.default_branch_name,
             self.commit_ids[commit_message])
         return reference
 
     def _get_reviewers(self):
         model = UserModel()
         return [
             model.get_by_username(TEST_USER_REGULAR_LOGIN),
             model.get_by_username(TEST_USER_REGULAR2_LOGIN),
         ]
 
     def update_source_repository(self, head=None):
         heads = [head or 'c3']
         self.backend.pull_heads(self.source_repository, heads=heads)
 
     def add_one_commit(self, head=None):
         self.update_source_repository(head=head)
         old_commit_ids = set(self.pull_request.revisions)
         PullRequestModel().update_commits(self.pull_request)
         commit_ids = set(self.pull_request.revisions)
         new_commit_ids = commit_ids - old_commit_ids
         assert len(new_commit_ids) == 1
         return new_commit_ids.pop()
 
     def remove_one_commit(self):
         assert len(self.pull_request.revisions) == 2
         source_vcs = self.source_repository.scm_instance()
         removed_commit_id = source_vcs.commit_ids[-1]
 
         # TODO: johbo: Git and Mercurial have an inconsistent vcs api here,
         # remove the if once that's sorted out.
         if self.backend.alias == "git":
             kwargs = {'branch_name': self.backend.default_branch_name}
         else:
             kwargs = {}
         source_vcs.strip(removed_commit_id, **kwargs)
 
         PullRequestModel().update_commits(self.pull_request)
         assert len(self.pull_request.revisions) == 1
         return removed_commit_id
 
     def create_comment(self, linked_to=None):
         comment = ChangesetCommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_inline_comment(
             self, linked_to=None, line_no=u'n1', file_path='file_1'):
         comment = ChangesetCommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             line_no=line_no,
             f_path=file_path,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_version_of_pull_request(self):
         pull_request = self.create_pull_request()
         version = PullRequestModel()._create_version_from_snapshot(
             pull_request)
         return version
 
     def create_status_votes(self, status, *reviewers):
         for reviewer in reviewers:
             ChangesetStatusModel().set_status(
                 repo=self.pull_request.target_repo,
                 status=status,
                 user=reviewer.user_id,
                 pull_request=self.pull_request)
 
     def set_mergeable(self, value):
         if not self.mergeable_patcher:
             self.mergeable_patcher = mock.patch.object(
                 VcsSettingsModel, 'get_general_settings')
             self.mergeable_mock = self.mergeable_patcher.start()
         self.mergeable_mock.return_value = {
             'rhodecode_pr_merge_enabled': value}
 
     def cleanup(self):
         # In case the source repository is already cleaned up, the pull
         # request will already be deleted.
         pull_request = PullRequest().get(self.pull_request_id)
         if pull_request:
             PullRequestModel().delete(pull_request)
             Session().commit()
 
         if self.notification_patcher:
             self.notification_patcher.stop()
 
         if self.mergeable_patcher:
             self.mergeable_patcher.stop()
 
 
 @pytest.fixture
 def user_admin(pylonsapp):
     """
     Provides the default admin test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
     return user
 
 
 @pytest.fixture
 def user_regular(pylonsapp):
     """
     Provides the default regular test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
     return user
 
 
 @pytest.fixture
 def user_util(request, pylonsapp):
     """
     Provides a wired instance of `UserUtility` with integrated cleanup.
     """
     utility = UserUtility(test_name=request.node.name)
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 # TODO: johbo: Split this up into utilities per domain or something similar
 class UserUtility(object):
 
     def __init__(self, test_name="test"):
         self._test_name = test_name
         self.fixture = Fixture()
         self.repo_group_ids = []
         self.user_ids = []
         self.user_group_ids = []
         self.user_repo_permission_ids = []
         self.user_group_repo_permission_ids = []
         self.user_repo_group_permission_ids = []
         self.user_group_repo_group_permission_ids = []
         self.user_user_group_permission_ids = []
         self.user_group_user_group_permission_ids = []
         self.user_permissions = []
 
     def create_repo_group(
             self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True):
         group_name = "{prefix}_repogroup_{count}".format(
             prefix=self._test_name,
             count=len(self.repo_group_ids))
         repo_group = self.fixture.create_repo_group(
             group_name, cur_user=owner)
         if auto_cleanup:
             self.repo_group_ids.append(repo_group.group_id)
         return repo_group
 
     def create_user(self, auto_cleanup=True, **kwargs):
         user_name = "{prefix}_user_{count}".format(
             prefix=self._test_name,
             count=len(self.user_ids))
         user = self.fixture.create_user(user_name, **kwargs)
         if auto_cleanup:
             self.user_ids.append(user.user_id)
         return user
 
     def create_user_with_group(self):
         user = self.create_user()
         user_group = self.create_user_group(members=[user])
         return user, user_group
 
     def create_user_group(self, members=None, auto_cleanup=True, **kwargs):
         group_name = "{prefix}_usergroup_{count}".format(
             prefix=self._test_name,
             count=len(self.user_group_ids))
         user_group = self.fixture.create_user_group(group_name, **kwargs)
         if auto_cleanup:
             self.user_group_ids.append(user_group.users_group_id)
         if members:
             for user in members:
                 UserGroupModel().add_user_to_group(user_group, user)
         return user_group
 
     def grant_user_permission(self, user_name, permission_name):
         self._inherit_default_user_permissions(user_name, False)
         self.user_permissions.append((user_name, permission_name))
 
     def grant_user_permission_to_repo_group(
             self, repo_group, user, permission_name):
         permission = RepoGroupModel().grant_user_permission(
             repo_group, user, permission_name)
         self.user_repo_group_permission_ids.append(
             (repo_group.group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo_group(
             self, repo_group, user_group, permission_name):
         permission = RepoGroupModel().grant_user_group_permission(
             repo_group, user_group, permission_name)
         self.user_group_repo_group_permission_ids.append(
             (repo_group.group_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_repo(
             self, repo, user, permission_name):
         permission = RepoModel().grant_user_permission(
             repo, user, permission_name)
         self.user_repo_permission_ids.append(
             (repo.repo_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo(
             self, repo, user_group, permission_name):
         permission = RepoModel().grant_user_group_permission(
             repo, user_group, permission_name)
         self.user_group_repo_permission_ids.append(
             (repo.repo_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_user_group(
             self, target_user_group, user, permission_name):
         permission = UserGroupModel().grant_user_permission(
             target_user_group, user, permission_name)
         self.user_user_group_permission_ids.append(
             (target_user_group.users_group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_user_group(
             self, target_user_group, user_group, permission_name):
         permission = UserGroupModel().grant_user_group_permission(
             target_user_group, user_group, permission_name)
         self.user_group_user_group_permission_ids.append(
             (target_user_group.users_group_id, user_group.users_group_id))
         return permission
 
     def revoke_user_permission(self, user_name, permission_name):
         self._inherit_default_user_permissions(user_name, True)
         UserModel().revoke_perm(user_name, permission_name)
 
     def _inherit_default_user_permissions(self, user_name, value):
         user = UserModel().get_by_username(user_name)
         user.inherit_default_permissions = value
         Session().add(user)
         Session().commit()
 
     def cleanup(self):
         self._cleanup_permissions()
         self._cleanup_repo_groups()
         self._cleanup_user_groups()
         self._cleanup_users()
 
     def _cleanup_permissions(self):
         if self.user_permissions:
             for user_name, permission_name in self.user_permissions:
                 self.revoke_user_permission(user_name, permission_name)
 
         for permission in self.user_repo_permission_ids:
             RepoModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_permission_ids:
             RepoModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_repo_group_permission_ids:
             RepoGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_group_permission_ids:
             RepoGroupModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_user_group_permission_ids:
             UserGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_user_group_permission_ids:
             UserGroupModel().revoke_user_group_permission(*permission)
 
     def _cleanup_repo_groups(self):
         def _repo_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = RepoGroup.get(first_group_id)
             second_group = RepoGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.group_name.split('/')) if first_group else 0)
             second_group_parts = (
                 len(second_group.group_name.split('/')) if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_repo_group_ids = sorted(
             self.repo_group_ids, cmp=_repo_group_compare)
         for repo_group_id in sorted_repo_group_ids:
             self.fixture.destroy_repo_group(repo_group_id)
 
     def _cleanup_user_groups(self):
         def _user_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = UserGroup.get(first_group_id)
             second_group = UserGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.users_group_name.split('/'))
                 if first_group else 0)
             second_group_parts = (
                 len(second_group.users_group_name.split('/'))
                 if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_user_group_ids = sorted(
             self.user_group_ids, cmp=_user_group_compare)
         for user_group_id in sorted_user_group_ids:
             self.fixture.destroy_user_group(user_group_id)
 
     def _cleanup_users(self):
         for user_id in self.user_ids:
             self.fixture.destroy_user(user_id)
 
 
 # TODO: Think about moving this into a pytest-pyro package and make it a
 # pytest plugin
 @pytest.hookimpl(tryfirst=True, hookwrapper=True)
 def pytest_runtest_makereport(item, call):
     """
     Adding the remote traceback if the exception has this information.
 
     Pyro4 attaches this information as the attribute `_pyroTraceback`
     to the exception instance.
     """
     outcome = yield
     report = outcome.get_result()
     if call.excinfo:
         _add_pyro_remote_traceback(report, call.excinfo.value)
 
 
 def _add_pyro_remote_traceback(report, exc):
     pyro_traceback = getattr(exc, '_pyroTraceback', None)
 
     if pyro_traceback:
         traceback = ''.join(pyro_traceback)
         section = 'Pyro4 remote traceback ' + report.when
         report.sections.append((section, traceback))
 
 
 @pytest.fixture(scope='session')
 def testrun():
     return {
         'uuid': uuid.uuid4(),
         'start': datetime.datetime.utcnow().isoformat(),
         'timestamp': int(time.time()),
     }
 
 
 @pytest.fixture(autouse=True)
 def collect_appenlight_stats(request, testrun):
     """
     This fixture reports memory consumtion of single tests.
 
     It gathers data based on `psutil` and sends them to Appenlight. The option
     ``--ae`` has te be used to enable this fixture and the API key for your
     application has to be provided in ``--ae-key``.
     """
     try:
         # cygwin cannot have yet psutil support.
         import psutil
     except ImportError:
         return
 
     if not request.config.getoption('--appenlight'):
         return
     else:
         # Only request the pylonsapp fixture if appenlight tracking is
         # enabled. This will speed up a test run of unit tests by 2 to 3
         # seconds if appenlight is not enabled.
         pylonsapp = request.getfuncargvalue("pylonsapp")
     url = '{}/api/logs'.format(request.config.getoption('--appenlight-url'))
     client = AppenlightClient(
         url=url,
         api_key=request.config.getoption('--appenlight-api-key'),
         namespace=request.node.nodeid,
         request=str(testrun['uuid']),
         testrun=testrun)
 
     client.collect({
         'message': "Starting",
     })
 
     server_and_port = pylonsapp.config['vcs.server']
     server = create_vcsserver_proxy(server_and_port)
     with server:
         vcs_pid = server.get_pid()
         server.run_gc()
     vcs_process = psutil.Process(vcs_pid)
     mem = vcs_process.memory_info()
     client.tag_before('vcsserver.rss', mem.rss)
     client.tag_before('vcsserver.vms', mem.vms)
 
     test_process = psutil.Process()
     mem = test_process.memory_info()
     client.tag_before('test.rss', mem.rss)
     client.tag_before('test.vms', mem.vms)
 
     client.tag_before('time', time.time())
 
     @request.addfinalizer
     def send_stats():
         client.tag_after('time', time.time())
         with server:
             gc_stats = server.run_gc()
         for tag, value in gc_stats.items():
             client.tag_after(tag, value)
         mem = vcs_process.memory_info()
         client.tag_after('vcsserver.rss', mem.rss)
         client.tag_after('vcsserver.vms', mem.vms)
 
         mem = test_process.memory_info()
         client.tag_after('test.rss', mem.rss)
         client.tag_after('test.vms', mem.vms)
 
         client.collect({
             'message': "Finished",
         })
         client.send_stats()
 
     return client
 
 
 class AppenlightClient():
 
     url_template = '{url}?protocol_version=0.5'
 
     def __init__(
             self, url, api_key, add_server=True, add_timestamp=True,
             namespace=None, request=None, testrun=None):
         self.url = self.url_template.format(url=url)
         self.api_key = api_key
         self.add_server = add_server
         self.add_timestamp = add_timestamp
         self.namespace = namespace
         self.request = request
         self.server = socket.getfqdn(socket.gethostname())
         self.tags_before = {}
         self.tags_after = {}
         self.stats = []
         self.testrun = testrun or {}
 
     def tag_before(self, tag, value):
         self.tags_before[tag] = value
 
     def tag_after(self, tag, value):
         self.tags_after[tag] = value
 
     def collect(self, data):
         if self.add_server:
             data.setdefault('server', self.server)
         if self.add_timestamp:
             data.setdefault('date', datetime.datetime.utcnow().isoformat())
         if self.namespace:
             data.setdefault('namespace', self.namespace)
         if self.request:
             data.setdefault('request', self.request)
         self.stats.append(data)
 
     def send_stats(self):
         tags = [
             ('testrun', self.request),
             ('testrun.start', self.testrun['start']),
             ('testrun.timestamp', self.testrun['timestamp']),
             ('test', self.namespace),
         ]
         for key, value in self.tags_before.items():
             tags.append((key + '.before', value))
             try:
                 delta = self.tags_after[key] - value
                 tags.append((key + '.delta', delta))
             except Exception:
                 pass
         for key, value in self.tags_after.items():
             tags.append((key + '.after', value))
         self.collect({
             'message': "Collected tags",
             'tags': tags,
         })
 
         response = requests.post(
             self.url,
             headers={
                 'X-appenlight-api-key': self.api_key},
             json=self.stats,
         )
 
         if not response.status_code == 200:
             pprint.pprint(self.stats)
             print response.headers
             print response.text
             raise Exception('Sending to appenlight failed')
 
 
 @pytest.fixture
 def gist_util(request, pylonsapp):
     """
     Provides a wired instance of `GistUtility` with integrated cleanup.
     """
     utility = GistUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class GistUtility(object):
     def __init__(self):
         self.fixture = Fixture()
         self.gist_ids = []
 
     def create_gist(self, **kwargs):
         gist = self.fixture.create_gist(**kwargs)
         self.gist_ids.append(gist.gist_id)
         return gist
 
     def cleanup(self):
         for id_ in self.gist_ids:
             self.fixture.destroy_gists(str(id_))
 
 
 @pytest.fixture
 def enabled_backends(request):
     backends = request.config.option.backends
     return backends[:]
 
 
 @pytest.fixture
 def settings_util(request):
     """
     Provides a wired instance of `SettingsUtility` with integrated cleanup.
     """
     utility = SettingsUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class SettingsUtility(object):
     def __init__(self):
         self.rhodecode_ui_ids = []
         self.rhodecode_setting_ids = []
         self.repo_rhodecode_ui_ids = []
         self.repo_rhodecode_setting_ids = []
 
     def create_repo_rhodecode_ui(
             self, repo, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1(
             '{}{}{}'.format(section, value, repo.repo_id)).hexdigest()
 
         setting = RepoRhodeCodeUi()
         setting.repository_id = repo.repo_id
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_rhodecode_ui(
             self, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1('{}{}'.format(section, value)).hexdigest()
 
         setting = RhodeCodeUi()
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_repo_rhodecode_setting(
             self, repo, name, value, type_, cleanup=True):
         setting = RepoRhodeCodeSetting(
             repo.repo_id, key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_setting_ids.append(setting.app_settings_id)
         return setting
 
     def create_rhodecode_setting(self, name, value, type_, cleanup=True):
         setting = RhodeCodeSetting(key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_setting_ids.append(setting.app_settings_id)
 
         return setting
 
     def cleanup(self):
         for id_ in self.rhodecode_ui_ids:
             setting = RhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.rhodecode_setting_ids:
             setting = RhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_ui_ids:
             setting = RepoRhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_setting_ids:
             setting = RepoRhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         Session().commit()
 
 
 @pytest.fixture
 def no_notifications(request):
     notification_patcher = mock.patch(
         'rhodecode.model.notification.NotificationModel.create')
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
 @pytest.fixture
 def silence_action_logger(request):
     notification_patcher = mock.patch(
         'rhodecode.lib.utils.action_logger')
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
 @pytest.fixture(scope='session')
 def repeat(request):
     """
     The number of repetitions is based on this fixture.
 
     Slower calls may divide it by 10 or 100. It is chosen in a way so that the
     tests are not too slow in our default test suite.
     """
     return request.config.getoption('--repeat')
 
 
 @pytest.fixture
 def rhodecode_fixtures():
     return Fixture()
 
 
 @pytest.fixture
 def request_stub():
     """
     Stub request object.
     """
     request = pyramid.testing.DummyRequest()
     request.scheme = 'https'
     return request
 
 
 @pytest.fixture
 def config_stub(request, request_stub):
     """
     Set up pyramid.testing and return the Configurator.
     """
     config = pyramid.testing.setUp(request=request_stub)
 
     @request.addfinalizer
     def cleanup():
         pyramid.testing.tearDown()
 
     return config
 
 
 @pytest.fixture
 def StubIntegrationType():
     class _StubIntegrationType(IntegrationTypeBase):
         """ Test integration type class """
 
         key = 'test'
         display_name = 'Test integration type'
         description = 'A test integration type for testing'
         icon = 'test_icon_html_image'
 
         def __init__(self, settings):
             super(_StubIntegrationType, self).__init__(settings)
             self.sent_events = [] # for testing
 
         def send_event(self, event):
             self.sent_events.append(event)
 
         def settings_schema(self):
             class SettingsSchema(colander.Schema):
                 test_string_field = colander.SchemaNode(
                     colander.String(),
                     missing=colander.required,
                     title='test string field',
                 )
                 test_int_field = colander.SchemaNode(
                     colander.Int(),
                     title='some integer setting',
                 )
             return SettingsSchema()
 
 
     integration_type_registry.register_integration_type(_StubIntegrationType)
     return _StubIntegrationType
 
 @pytest.fixture
 def stub_integration_settings():
     return {
         'test_string_field': 'some data',
         'test_int_field': 100,
     }
 
 
 @pytest.fixture
 def repo_integration_stub(request, repo_stub, StubIntegrationType,
         stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
-        name='test repo integration', scope=repo_stub)
+        name='test repo integration',
+        repo=repo_stub, repo_group=None, child_repos_only=None)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def repogroup_integration_stub(request, test_repo_group, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
-        name='test repogroup integration', scope=test_repo_group)
+        name='test repogroup integration',
+        repo=None, repo_group=test_repo_group, child_repos_only=True)
+
+    @request.addfinalizer
+    def cleanup():
+        IntegrationModel().delete(integration)
+
+    return integration
+
+
[e-mail]
+def repogroup_recursive_integration_stub(request, test_repo_group,
+    StubIntegrationType, stub_integration_settings):
+    integration = IntegrationModel().create(
+        StubIntegrationType, settings=stub_integration_settings, enabled=True,
+        name='test recursive repogroup integration',
+        repo=None, repo_group=test_repo_group, child_repos_only=False)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def global_integration_stub(request, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
-        name='test global integration', scope='global')
+        name='test global integration',
+        repo=None, repo_group=None, child_repos_only=None)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def root_repos_integration_stub(request, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
-        name='test global integration', scope='root_repos')
+        name='test global integration',
+        repo=None, repo_group=None, child_repos_only=True)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration