integrations-db: don't use default contructor to be consisten with other modules

usage.

rhodecode/integrations/views.py

@@ -1,258 +1,258 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 colander
 import logging
 import pylons
 
 from pyramid.httpexceptions import HTTPFound, HTTPForbidden
 from pyramid.renderers import render
 from pyramid.response import Response
 
 from rhodecode.lib import auth
 from rhodecode.lib.auth import LoginRequired, HasPermissionAllDecorator
 from rhodecode.model.db import Repository, 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
 
 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.integration = None
         self.integrations = {}
 
         request = self.request
 
         if 'repo_name' in request.matchdict:  # we're in a repo context
             repo_name = request.matchdict['repo_name']
             self.repo = Repository.get_by_repo_name(repo_name)
 
         if 'integration' in request.matchdict:  # we're in integration 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)
         else:                                      # list integrations context
             for integration in IntegrationModel().get_integrations(self.repo):
                 self.integrations.setdefault(integration.integration_type, []
                     ).append(integration)
 
         self.settings = self.integration and self.integration.settings or {}
 
     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_name = self.repo and self.repo.repo_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):
         return self.IntegrationType.settings_schema()
 
     def settings_get(self, defaults=None, errors=None):
         """
         View that displays the plugin settings as a form.
         """
         defaults = defaults or {}
         errors = errors or {}
 
         schema = self._form_schema()
 
         if not defaults:
             if self.integration:
                 defaults['enabled'] = self.integration.enabled
                 defaults['name'] = self.integration.name
             else:
                 if self.repo:
                     scope = self.repo.repo_name
                 else:
                     scope = _('Global')
 
                 defaults['name'] = '{} {} integration'.format(scope,
                     self.IntegrationType.display_name)
                 defaults['enabled'] = True
 
         for node in schema:
             setting = self.settings.get(node.name)
             if setting is not None:
                 defaults.setdefault(node.name, setting)
             else:
                 if node.default:
                     defaults.setdefault(node.name, node.default)
 
         template_context = {
             'defaults': defaults,
             'errors': errors,
             'schema': schema,
             'current_IntegrationType': self.IntegrationType,
             'integration': self.integration,
             'settings': self.settings,
             'resource': self.context,
             'c': self._template_c_context(),
         }
 
         return template_context
 
     @auth.CSRFRequired()
     def settings_post(self):
         """
         View that validates and stores the plugin settings.
         """
         if self.request.params.get('delete'):
             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)
             else:
                 redirect_to = self.request.route_url('global_integrations_home')
             raise HTTPFound(redirect_to)
 
         schema = self._form_schema()
 
         params = {}
         for node in schema.children:
             if type(node.typ) in (colander.Set, colander.List):
                 val = self.request.params.getall(node.name)
             else:
                 val = self.request.params.get(node.name)
             if val:
                 params[node.name] = val
 
         try:
             valid_data = schema.deserialize(params)
-        except colander.Invalid, e:
+        except colander.Invalid as e:
             # Display error message and display form again.
             self.request.session.flash(
                 _('Errors exist when saving plugin settings. '
                   'Please check the form inputs.'),
                 queue='error')
             return self.settings_get(errors=e.asdict(), defaults=params)
 
         if not self.integration:
-            self.integration = Integration(
-                integration_type=self.IntegrationType.key)
+            self.integration = Integration()
+            self.integration.integration_type = self.IntegrationType.key
             if self.repo:
                 self.integration.repo = self.repo
-            Session.add(self.integration)
+            Session().add(self.integration)
 
         self.integration.enabled = valid_data.pop('enabled', False)
         self.integration.name = valid_data.pop('name')
         self.integration.settings = valid_data
 
-        Session.commit()
+        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 self.repo:
             redirect_to = self.request.route_url(
                 'repo_integrations_edit', repo_name=self.repo.repo_name,
                 integration=self.integration.integration_type,
                 integration_id=self.integration.integration_id)
         else:
             redirect_to = self.request.route_url(
                 'global_integrations_edit',
                 integration=self.integration.integration_type,
                 integration_id=self.integration.integration_id)
 
         return HTTPFound(redirect_to)
 
     def index(self):
         current_integrations = self.integrations
         if self.IntegrationType:
             current_integrations = {
                 self.IntegrationType.key: self.integrations.get(
                     self.IntegrationType.key, [])
             }
 
         template_context = {
             'current_IntegrationType': self.IntegrationType,
             'current_integrations': current_integrations,
             'current_integration': 'none',
             'available_integrations': integration_type_registry,
             'c': self._template_c_context()
         }
 
         if self.repo:
             html = render('rhodecode:templates/admin/integrations/list.html',
                           template_context,
                           request=self.request)
         else:
             html = render('rhodecode:templates/admin/integrations/list.html',
                           template_context,
                           request=self.request)
 
         return Response(html)
 
 
 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)

rhodecode/model/integration.py

@@ -1,132 +1,132 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_
 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
 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, enabled, name, settings, repo=None):
         """ Create an IntegrationType integration """
-        integration = Integration(
-            integration_type=IntegrationType.key,
-            settings={},
-            repo=repo,
-            enabled=enabled,
-            name=name
-        )
+        integration = Integration()
+        integration.integration_type = IntegrationType.key
+        integration.settings = {}
+        integration.repo = repo
+        integration.enabled = enabled
+        integration.name = name
+
         self.sa.add(integration)
         self.sa.commit()
         return integration
 
     def delete(self, integration):
         try:
             integration = self.__get_integration(integration)
             if integration:
                 self.sa.delete(integration)
                 return True
         except Exception:
             log.error(traceback.format_exc())
             raise
         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, repo=None):
         if repo:
             return self.sa.query(Integration).filter(
                 Integration.repo_id==repo.repo_id).all()
 
         # global integrations
         return self.sa.query(Integration).filter(
             Integration.repo_id==None).all()
 
     def get_for_event(self, event, cache=False):
         """
         Get integrations that match an event
         """
         query = self.sa.query(Integration).filter(Integration.enabled==True)
 
         if isinstance(event, events.RepoEvent): # global + repo integrations
             query = query.filter(
                         or_(Integration.repo_id==None,
                             Integration.repo_id==event.repo.repo_id))
             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(Integration.repo_id==None)
             if cache:
                 query = query.options(FromCache(
                     "sql_cache_short", "get_enabled_global_integrations"))
 
         return query.all()

rhodecode/tests/integrations/test_slack.py

@@ -1,96 +1,95 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 pytest
 import requests
 from mock import Mock, patch
 
 from rhodecode import events
 from rhodecode.model.db import Session, Integration
 from rhodecode.integrations.types.slack import SlackIntegrationType
 
 @pytest.fixture
 def repo_push_event(backend, user_regular):
     commits = [
         {'message': 'ancestor commit fixes #15'},
         {'message': 'quick fixes'},
         {'message': 'change that fixes #41, #2'},
         {'message': 'this is because 5b23c3532 broke stuff'},
         {'message': 'last commit'},
     ]
     commit_ids = backend.create_master_repo(commits).values()
     repo = backend.create_repo()
     scm_extras = {
         'ip': '127.0.0.1',
         'username': user_regular.username,
         'action': '',
         'repository': repo.repo_name,
         'scm': repo.scm_instance().alias,
         'config': '',
         'server_url': 'http://example.com',
         'make_lock': None,
         'locked_by': [None],
         'commit_ids': commit_ids,
     }
 
     return events.RepoPushEvent(repo_name=repo.repo_name,
                                 pushed_commit_ids=commit_ids,
                                 extras=scm_extras)
 
 
 @pytest.fixture
 def slack_settings():
     return {
         "service": "mock://slackintegration",
         "events": [
            "pullrequest-create",
            "repo-push",
         ],
         "channel": "#testing",
         "icon_emoji": ":recycle:",
         "username": "rhodecode-test"
     }
 
 
 @pytest.fixture
 def slack_integration(request, app, slack_settings):
-    integration = Integration(
-        name='test slack integration',
-        enabled=True,
-        integration_type=SlackIntegrationType.key
-    )
+    integration = Integration()
+    integration.name = 'test slack integration'
+    integration.enabled = True
+    integration.integration_type = SlackIntegrationType.key
     integration.settings = slack_settings
     Session().add(integration)
     Session().commit()
     request.addfinalizer(lambda: Session().delete(integration))
     return integration
 
 
 def test_slack_push(slack_integration, repo_push_event):
     with patch('rhodecode.integrations.types.slack.post_text_to_slack') as call:
         events.trigger(repo_push_event)
     assert 'pushed to' in call.call_args[0][1]
 
     slack_integration.settings['events'] = []
     Session().commit()
 
     with patch('rhodecode.integrations.types.slack.post_text_to_slack') as call:
         events.trigger(repo_push_event)
     assert not call.call_args