webhook: handle ${commit_id} variable independent from ${branch}.

- in some cases we want non-branched individual commits to be posted.

rhodecode/integrations/tests/test_integrations.py

@@ -1,269 +1,270 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 
 from rhodecode.apps._base import ADMIN_PREFIX
 from rhodecode.model.db import Integration
 from rhodecode.model.meta import Session
 from rhodecode.integrations import integration_type_registry
 
 
 def route_path(name, **kwargs):
     return {
         'home': '/',
     }[name].format(**kwargs)
 
 
+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.
+    """
+    repo_name = repo.repo_name
+    repo_group_name = repo_group.group_name
+    app.post(url, params={}, status=403)  # missing csrf check
+    response = app.post(url, params={'csrf_token': csrf_token})
+    assert response.status_code == 200
+    response.mustcontain('Errors exist')
+
+    scopes_destinations = [
+        ('global',
+                ADMIN_PREFIX + '/integrations'),
+        ('root-repos',
+                ADMIN_PREFIX + '/integrations'),
+        ('repo:%s' % repo_name,
+                '/%s/settings/integrations' % repo_name),
+        ('repogroup:%s' % repo_group_name,
+                '/%s/_settings/integrations' % repo_group_name),
+        ('repogroup-recursive:%s' % repo_group_name,
+                '/%s/_settings/integrations' % repo_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)
+
+
+
 @pytest.mark.usefixtures('app', 'autologin_user')
 class TestIntegrationsView(object):
     pass
 
 
 class TestGlobalIntegrationsView(TestIntegrationsView):
     def test_index_no_integrations(self):
         url = ADMIN_PREFIX + '/integrations'
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain('exist yet')
 
     def test_index_with_integrations(self, global_integration_stub):
         url = ADMIN_PREFIX + '/integrations'
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain(no=['exist yet'])
         response.mustcontain(global_integration_stub.name)
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_new_integration_page(self, IntegrationType):
         url = ADMIN_PREFIX + '/integrations/new'
 
         response = self.app.get(url, status=200)
         if not IntegrationType.is_dummy:
             url = (ADMIN_PREFIX + '/integrations/{integration}/new').format(
                     integration=IntegrationType.key)
             response.mustcontain(url)
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_get_create_integration_page(self, IntegrationType):
         url = ADMIN_PREFIX + '/integrations/{integration_key}/new'.format(
             integration_key=IntegrationType.key)
         if IntegrationType.is_dummy:
             self.app.get(url, status=404)
         else:
             response = self.app.get(url, status=200)
             response.mustcontain(IntegrationType.display_name)
 
     def test_post_integration_page(self, StubIntegrationType, csrf_token,
                                    test_repo_group, backend_random):
         url = ADMIN_PREFIX + '/integrations/{integration_key}/new'.format(
             integration_key=StubIntegrationType.key)
 
         _post_integration_test_helper(
             self.app, url, csrf_token, admin_view=True,
             repo=backend_random.repo, repo_group=test_repo_group)
 
 
 class TestRepoIntegrationsView(TestIntegrationsView):
     def test_index_no_integrations(self, backend_random):
         url = '/{repo_name}/settings/integrations'.format(
             repo_name=backend_random.repo.repo_name)
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain('exist yet')
 
     def test_index_with_integrations(self, repo_integration_stub):
         url = '/{repo_name}/settings/integrations'.format(
             repo_name=repo_integration_stub.repo.repo_name)
         stub_name = repo_integration_stub.name
 
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain(stub_name)
         response.mustcontain(no=['exist yet'])
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_new_integration_page(self, backend_random, IntegrationType):
         repo_name = backend_random.repo.repo_name
         url = '/{repo_name}/settings/integrations/new'.format(
             repo_name=repo_name)
 
         response = self.app.get(url, status=200)
 
         url = '/{repo_name}/settings/integrations/{integration}/new'.format(
                 repo_name=repo_name,
                 integration=IntegrationType.key)
         if not IntegrationType.is_dummy:
             response.mustcontain(url)
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_get_create_integration_page(self, 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)
         if IntegrationType.is_dummy:
             self.app.get(url, status=404)
         else:
             response = self.app.get(url, status=200)
             response.mustcontain(IntegrationType.display_name)
 
     def test_post_integration_page(self, 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(
             self.app, url, csrf_token, admin_view=False,
             repo=backend_random.repo, repo_group=test_repo_group)
 
 
 class TestRepoGroupIntegrationsView(TestIntegrationsView):
     def test_index_no_integrations(self, test_repo_group):
         url = '/{repo_group_name}/_settings/integrations'.format(
             repo_group_name=test_repo_group.group_name)
         response = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain('exist yet')
 
     def test_index_with_integrations(
             self, 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 = self.app.get(url)
 
         assert response.status_code == 200
         response.mustcontain(no=['exist yet'])
         response.mustcontain(stub_name)
 
     def test_new_integration_page(self, 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 = self.app.get(url)
 
         assert response.status_code == 200
 
         for integration_key, integration_obj in integration_type_registry.items():
             if not integration_obj.is_dummy:
                 nurl = (
                     '/{repo_group_name}/_settings/integrations/{integration}/new').format(
                     repo_group_name=repo_group_name,
                     integration=integration_key)
                 response.mustcontain(nurl)
 
     @pytest.mark.parametrize(
         'IntegrationType', integration_type_registry.values())
     def test_get_create_integration_page(
             self, 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)
 
         if not IntegrationType.is_dummy:
             response = self.app.get(url, status=200)
             response.mustcontain(IntegrationType.display_name)
         else:
             self.app.get(url, status=404)
 
     def test_post_integration_page(self, 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(
             self.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.
-    """
-    repo_name = repo.repo_name
-    repo_group_name = repo_group.group_name
-    app.post(url, params={}, status=403)  # missing csrf check
-    response = app.post(url, params={'csrf_token': csrf_token})
-    assert response.status_code == 200
-    response.mustcontain('Errors exist')
-
-    scopes_destinations = [
-        ('global',
-                ADMIN_PREFIX + '/integrations'),
-        ('root-repos',
-                ADMIN_PREFIX + '/integrations'),
-        ('repo:%s' % repo_name,
-                '/%s/settings/integrations' % repo_name),
-        ('repogroup:%s' % repo_group_name,
-                '/%s/_settings/integrations' % repo_group_name),
-        ('repogroup-recursive:%s' % repo_group_name,
-                '/%s/_settings/integrations' % repo_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/integrations/types/base.py

@@ -1,322 +1,322 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2012-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import colander
 import string
 import collections
 import logging
 
 from mako import exceptions
 
 from rhodecode.translation import _
 
 
 log = logging.getLogger(__name__)
 
 
 class IntegrationTypeBase(object):
     """ Base class for IntegrationType plugins """
     is_dummy = False
     description = ''
 
     @classmethod
     def icon(cls):
         return '''
         <?xml version="1.0" encoding="UTF-8" standalone="no"?>
         <svg
            xmlns:dc="http://purl.org/dc/elements/1.1/"
            xmlns:cc="http://creativecommons.org/ns#"
            xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
            xmlns:svg="http://www.w3.org/2000/svg"
            xmlns="http://www.w3.org/2000/svg"
            xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
            xmlns:inkscape="http://setwww.inkscape.org/namespaces/inkscape"
            viewBox="0 -256 1792 1792"
            id="svg3025"
            version="1.1"
            inkscape:version="0.48.3.1 r9886"
            width="100%"
            height="100%"
            sodipodi:docname="cog_font_awesome.svg">
           <metadata
              id="metadata3035">
             <rdf:RDF>
               <cc:Work
                  rdf:about="">
                 <dc:format>image/svg+xml</dc:format>
                 <dc:type
                    rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
               </cc:Work>
             </rdf:RDF>
           </metadata>
           <defs
              id="defs3033" />
           <sodipodi:namedview
              pagecolor="#ffffff"
              bordercolor="#666666"
              borderopacity="1"
              objecttolerance="10"
              gridtolerance="10"
              guidetolerance="10"
              inkscape:pageopacity="0"
              inkscape:pageshadow="2"
              inkscape:window-width="640"
              inkscape:window-height="480"
              id="namedview3031"
              showgrid="false"
              inkscape:zoom="0.13169643"
              inkscape:cx="896"
              inkscape:cy="896"
              inkscape:window-x="0"
              inkscape:window-y="25"
              inkscape:window-maximized="0"
              inkscape:current-layer="svg3025" />
           <g
              transform="matrix(1,0,0,-1,121.49153,1285.4237)"
              id="g3027">
             <path
                d="m 1024,640 q 0,106 -75,181 -75,75 -181,75 -106,0 -181,-75 -75,-75 -75,-181 0,-106 75,-181 75,-75 181,-75 106,0 181,75 75,75 75,181 z m 512,109 V 527 q 0,-12 -8,-23 -8,-11 -20,-13 l -185,-28 q -19,-54 -39,-91 35,-50 107,-138 10,-12 10,-25 0,-13 -9,-23 -27,-37 -99,-108 -72,-71 -94,-71 -12,0 -26,9 l -138,108 q -44,-23 -91,-38 -16,-136 -29,-186 -7,-28 -36,-28 H 657 q -14,0 -24.5,8.5 Q 622,-111 621,-98 L 593,86 q -49,16 -90,37 L 362,16 Q 352,7 337,7 323,7 312,18 186,132 147,186 q -7,10 -7,23 0,12 8,23 15,21 51,66.5 36,45.5 54,70.5 -27,50 -41,99 L 29,495 Q 16,497 8,507.5 0,518 0,531 v 222 q 0,12 8,23 8,11 19,13 l 186,28 q 14,46 39,92 -40,57 -107,138 -10,12 -10,24 0,10 9,23 26,36 98.5,107.5 72.5,71.5 94.5,71.5 13,0 26,-10 l 138,-107 q 44,23 91,38 16,136 29,186 7,28 36,28 h 222 q 14,0 24.5,-8.5 Q 914,1391 915,1378 l 28,-184 q 49,-16 90,-37 l 142,107 q 9,9 24,9 13,0 25,-10 129,-119 165,-170 7,-8 7,-22 0,-12 -8,-23 -15,-21 -51,-66.5 -36,-45.5 -54,-70.5 26,-50 41,-98 l 183,-28 q 13,-2 21,-12.5 8,-10.5 8,-23.5 z"
                id="path3029"
                inkscape:connector-curvature="0"
                style="fill:currentColor" />
           </g>
         </svg>
         '''
 
     def __init__(self, settings):
         """
         :param settings: dict of settings to be used for the integration
         """
         self.settings = settings
 
     def settings_schema(self):
         """
         A colander schema of settings for the integration type
         """
         return colander.Schema()
 
 
 class EEIntegration(IntegrationTypeBase):
     description = 'Integration available in RhodeCode EE edition.'
     is_dummy = True
 
     def __init__(self, name, key, settings=None):
         self.display_name = name
         self.key = key
         super(EEIntegration, self).__init__(settings)
 
 
 # Helpers #
 # updating this required to update the `common_vars` as well.
 WEBHOOK_URL_VARS = [
     ('event_name', 'Unique name of the event type, e.g pullrequest-update'),
     ('repo_name', 'Full name of the repository'),
     ('repo_type', 'VCS type of repository'),
     ('repo_id', 'Unique id of repository'),
     ('repo_url', 'Repository url'),
     # extra repo fields
     ('extra:<extra_key_name>', 'Extra repo variables, read from its settings.'),
 
     # special attrs below that we handle, using multi-call
     ('branch', 'Name of each branch submitted, if any.'),
     ('branch_head', 'Head ID of pushed branch (full sha of last commit), if any.'),
     ('commit_id', 'ID (full sha) of each commit submitted, if any.'),
 
     # pr events vars
     ('pull_request_id', 'Unique ID of the pull request.'),
     ('pull_request_title', 'Title of the pull request.'),
     ('pull_request_url', 'Pull request url.'),
     ('pull_request_shadow_url', 'Pull request shadow repo clone url.'),
     ('pull_request_commits_uid', 'Calculated UID of all commits inside the PR. '
                                  'Changes after PR update'),
 
     # user who triggers the call
     ('username', 'User who triggered the call.'),
     ('user_id', 'User id who triggered the call.'),
 ]
 
 # common vars for url template used for CI plugins. Shared with webhook
 CI_URL_VARS = WEBHOOK_URL_VARS
 
 
 class CommitParsingDataHandler(object):
 
     def aggregate_branch_data(self, branches, commits):
         branch_data = collections.OrderedDict()
         for obj in branches:
             branch_data[obj['name']] = obj
 
         branches_commits = collections.OrderedDict()
         for commit in commits:
             if commit.get('git_ref_change'):
                 # special case for GIT that allows creating tags,
                 # deleting branches without associated commit
                 continue
             commit_branch = commit['branch']
 
             if commit_branch not in branches_commits:
                 _branch = branch_data[commit_branch] \
                     if commit_branch else commit_branch
                 branch_commits = {'branch': _branch,
                                   'branch_head': '',
                                   'commits': []}
                 branches_commits[commit_branch] = branch_commits
 
             branch_commits = branches_commits[commit_branch]
             branch_commits['commits'].append(commit)
             branch_commits['branch_head'] = commit['raw_id']
         return branches_commits
 
 
 class WebhookDataHandler(CommitParsingDataHandler):
     name = 'webhook'
 
     def __init__(self, template_url, headers):
         self.template_url = template_url
         self.headers = headers
 
     def get_base_parsed_template(self, data):
         """
         initially parses the passed in template with some common variables
         available on ALL calls
         """
         # note: make sure to update the `WEBHOOK_URL_VARS` if this changes
         common_vars = {
             'repo_name': data['repo']['repo_name'],
             'repo_type': data['repo']['repo_type'],
             'repo_id': data['repo']['repo_id'],
             'repo_url': data['repo']['url'],
             'username': data['actor']['username'],
             'user_id': data['actor']['user_id'],
             'event_name': data['name']
         }
 
         extra_vars = {}
         for extra_key, extra_val in data['repo']['extra_fields'].items():
             extra_vars['extra__{}'.format(extra_key)] = extra_val
         common_vars.update(extra_vars)
 
         template_url = self.template_url.replace('${extra:', '${extra__')
         return string.Template(template_url).safe_substitute(**common_vars)
 
     def repo_push_event_handler(self, event, data):
         url = self.get_base_parsed_template(data)
-        url_cals = []
+        url_calls = []
 
         branches_commits = self.aggregate_branch_data(
             data['push']['branches'], data['push']['commits'])
-        if '${branch}' in url or '${branch_head}' in url:
+        if '${branch}' in url or '${branch_head}' in url or '${commit_id}' in url:
             # call it multiple times, for each branch if used in variables
             for branch, commit_ids in branches_commits.items():
                 branch_url = string.Template(url).safe_substitute(branch=branch)
 
                 if '${branch_head}' in branch_url:
                     # last commit in the aggregate is the head of the branch
                     branch_head = commit_ids['branch_head']
                     branch_url = string.Template(branch_url).safe_substitute(
                         branch_head=branch_head)
 
                 # call further down for each commit if used
                 if '${commit_id}' in branch_url:
                     for commit_data in commit_ids['commits']:
                         commit_id = commit_data['raw_id']
                         commit_url = string.Template(branch_url).safe_substitute(
                             commit_id=commit_id)
                         # register per-commit call
                         log.debug(
                             'register %s call(%s) to url %s',
                             self.name, event, commit_url)
-                        url_cals.append(
+                        url_calls.append(
                             (commit_url, self.headers, data))
 
                 else:
                     # register per-branch call
                     log.debug(
                         'register %s call(%s) to url %s',
                         self.name, event, branch_url)
-                    url_cals.append(
+                    url_calls.append(
                         (branch_url, self.headers, data))
 
         else:
             log.debug(
                 'register %s call(%s) to url %s', self.name, event, url)
-            url_cals.append((url, self.headers, data))
+            url_calls.append((url, self.headers, data))
 
-        return url_cals
+        return url_calls
 
     def repo_create_event_handler(self, event, data):
         url = self.get_base_parsed_template(data)
         log.debug(
             'register %s call(%s) to url %s', self.name, event, url)
         return [(url, self.headers, data)]
 
     def pull_request_event_handler(self, event, data):
         url = self.get_base_parsed_template(data)
         log.debug(
             'register %s call(%s) to url %s', self.name, event, url)
         url = string.Template(url).safe_substitute(
             pull_request_id=data['pullrequest']['pull_request_id'],
             pull_request_title=data['pullrequest']['title'],
             pull_request_url=data['pullrequest']['url'],
             pull_request_shadow_url=data['pullrequest']['shadow_url'],
             pull_request_commits_uid=data['pullrequest']['commits_uid'],
         )
         return [(url, self.headers, data)]
 
     def __call__(self, event, data):
         from rhodecode import events
 
         if isinstance(event, events.RepoPushEvent):
             return self.repo_push_event_handler(event, data)
         elif isinstance(event, events.RepoCreateEvent):
             return self.repo_create_event_handler(event, data)
         elif isinstance(event, events.PullRequestEvent):
             return self.pull_request_event_handler(event, data)
         else:
             raise ValueError(
                 'event type `%s` not in supported list: %s' % (
                     event.__class__, events))
 
 
 def get_auth(settings):
     from requests.auth import HTTPBasicAuth
     username = settings.get('username')
     password = settings.get('password')
     if username and password:
         return HTTPBasicAuth(username, password)
     return None
 
 
 def get_web_token(settings):
     return settings['secret_token']
 
 
 def get_url_vars(url_vars):
     return '\n'.join(
         '{} - {}'.format('${' + key + '}', explanation)
         for key, explanation in url_vars)
 
 
 def render_with_traceback(template, *args, **kwargs):
     try:
         return template.render(*args, **kwargs)
     except Exception:
         log.error(exceptions.text_error_template().render())
         raise

rhodecode/tests/integrations/test_webhook.py

@@ -1,124 +1,132 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2018 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import pytest
 
 from rhodecode import events
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.integrations.types.webhook import WebhookDataHandler
 
 
 @pytest.fixture
 def base_data():
     return {
         'name': 'event',
         'repo': {
             'repo_name': 'foo',
             'repo_type': 'hg',
             'repo_id': '12',
             'url': 'http://repo.url/foo',
             'extra_fields': {},
         },
         'actor': {
             'username': 'actor_name',
             'user_id': 1
         }
     }
 
 
 def test_webhook_parse_url_invalid_event():
     template_url = 'http://server.com/${repo_name}/build'
     handler = WebhookDataHandler(
         template_url, {'exmaple-header': 'header-values'})
     event = events.RepoDeleteEvent('')
     with pytest.raises(ValueError) as err:
         handler(event, {})
 
     err = str(err.value)
     assert err.startswith(
         'event type `%s` not in supported list' % event.__class__)
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${repo_name}/build',
      ['http://server.com/foo/build']),
     ('http://server.com/${repo_name}/${repo_type}',
      ['http://server.com/foo/hg']),
     ('http://${server}.com/${repo_name}/${repo_id}',
      ['http://${server}.com/foo/12']),
     ('http://server.com/${branch}/build',
      ['http://server.com/${branch}/build']),
 ])
 def test_webook_parse_url_for_create_event(base_data, template, expected_urls):
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(events.RepoCreateEvent(''), base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${repo_name}/${pull_request_id}',
      ['http://server.com/foo/999']),
     ('http://server.com/${repo_name}/${pull_request_url}',
      ['http://server.com/foo/http://pr-url.com']),
 ])
 def test_webook_parse_url_for_pull_request_event(
         base_data, template, expected_urls):
 
     base_data['pullrequest'] = {
         'pull_request_id': 999,
         'url': 'http://pr-url.com',
         'title': 'example-pr-title',
         'commits_uid': 'abcdefg1234',
         'shadow_url': 'http://pr-url.com/repository'
     }
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(events.PullRequestCreateEvent(
         AttributeDict({'target_repo': 'foo'})), base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]
 
 
 @pytest.mark.parametrize('template,expected_urls', [
     ('http://server.com/${branch}/build',
         ['http://server.com/stable/build',
          'http://server.com/dev/build']),
     ('http://server.com/${branch}/${commit_id}',
         ['http://server.com/stable/stable-xxx',
          'http://server.com/stable/stable-yyy',
          'http://server.com/dev/dev-xxx',
          'http://server.com/dev/dev-yyy']),
+    ('http://server.com/${branch_head}',
+     ['http://server.com/stable-yyy',
+      'http://server.com/dev-yyy']),
+    ('http://server.com/${commit_id}',
+     ['http://server.com/stable-xxx',
+      'http://server.com/stable-yyy',
+      'http://server.com/dev-xxx',
+      'http://server.com/dev-yyy']),
 ])
 def test_webook_parse_url_for_push_event(
         baseapp, repo_push_event, base_data, template, expected_urls):
     base_data['push'] = {
         'branches': [{'name': 'stable'}, {'name': 'dev'}],
         'commits': [{'branch': 'stable', 'raw_id': 'stable-xxx'},
                     {'branch': 'stable', 'raw_id': 'stable-yyy'},
                     {'branch': 'dev', 'raw_id': 'dev-xxx'},
                     {'branch': 'dev', 'raw_id': 'dev-yyy'}]
     }
     headers = {'exmaple-header': 'header-values'}
     handler = WebhookDataHandler(template, headers)
     urls = handler(repo_push_event, base_data)
     assert urls == [
         (url, headers, base_data) for url in expected_urls]