Pylons application test package

This package assumes the Pylons environment is already loaded.

This module initializes the application via ``websetup`` (`paster

setup-app`) and provides the base testing objects.

Refer to docs/contributing.rst for details on running the test suite.

"""

import os

import re

import time

import logging

import datetime

import hashlib

import tempfile

from os.path import join as jn

from tempfile import _RandomNameSequence

import pylons

import pylons.test

from pylons import config, url

from pylons.i18n.translation import _get_translator

from pylons.util import ContextObj

from routes.util import URLGenerator

from webtest import TestApp

import pytest

from kallithea.lib.compat import unittest

from kallithea import is_windows

from kallithea.model.db import Notification, User, UserNotification

from kallithea.model.meta import Session

from kallithea.tests.parameterized import parameterized

from kallithea.lib.utils2 import safe_str

os.environ['TZ'] = 'UTC'

if not is_windows:

    time.tzset()

log = logging.getLogger(__name__)

skipif = pytest.mark.skipif

parametrize = pytest.mark.parametrize

__all__ = [

    'ldap_lib_installed', 'pam_lib_installed',

    'TESTS_TMP_PATH', 'HG_REPO', 'GIT_REPO', 'NEW_HG_REPO', 'NEW_GIT_REPO',

    'HG_FORK', 'GIT_FORK', 'TEST_USER_ADMIN_LOGIN', 'TEST_USER_ADMIN_PASS',

    'TEST_USER_ADMIN_EMAIL', 'TEST_USER_REGULAR_LOGIN', 'TEST_USER_REGULAR_PASS',

    'TEST_USER_REGULAR_EMAIL', 'TEST_USER_REGULAR2_LOGIN',

    'TEST_USER_REGULAR2_PASS', 'TEST_USER_REGULAR2_EMAIL', 'TEST_HG_REPO',

    'TEST_HG_REPO_CLONE', 'TEST_HG_REPO_PULL', 'TEST_GIT_REPO',

    'TEST_GIT_REPO_CLONE', 'TEST_GIT_REPO_PULL', 'HG_REMOTE_REPO',

    'GIT_REMOTE_REPO', 'SCM_TESTS',

]

# Invoke websetup with the current config file

# SetupCommand('setup-app').run([config_file])

environ = {}

#SOME GLOBALS FOR TESTS

TESTS_TMP_PATH = jn(tempfile.gettempdir(), 'rc_test_%s' % _RandomNameSequence().next())

TEST_USER_ADMIN_LOGIN = 'test_admin'

TEST_USER_ADMIN_PASS = 'test12'

TEST_USER_ADMIN_EMAIL = 'test_admin@example.com'

TEST_USER_REGULAR_LOGIN = 'test_regular'

TEST_USER_REGULAR_PASS = 'test12'

TEST_USER_REGULAR_EMAIL = 'test_regular@example.com'

TEST_USER_REGULAR2_LOGIN = 'test_regular2'

TEST_USER_REGULAR2_PASS = 'test12'

TEST_USER_REGULAR2_EMAIL = 'test_regular2@example.com'

HG_REPO = u'vcs_test_hg'

GIT_REPO = u'vcs_test_git'

NEW_HG_REPO = u'vcs_test_hg_new'

NEW_GIT_REPO = u'vcs_test_git_new'

HG_FORK = u'vcs_test_hg_fork'

GIT_FORK = u'vcs_test_git_fork'

## VCS

SCM_TESTS = ['hg', 'git']

uniq_suffix = str(int(time.mktime(datetime.datetime.now().timetuple())))

GIT_REMOTE_REPO = 'git://github.com/codeinn/vcs.git'

TEST_GIT_REPO = jn(TESTS_TMP_PATH, GIT_REPO)

TEST_GIT_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcsgitclone%s' % uniq_suffix)

TEST_GIT_REPO_PULL = jn(TESTS_TMP_PATH, 'vcsgitpull%s' % uniq_suffix)

HG_REMOTE_REPO = 'http://bitbucket.org/marcinkuzminski/vcs'

TEST_HG_REPO = jn(TESTS_TMP_PATH, HG_REPO)

TEST_HG_REPO_CLONE = jn(TESTS_TMP_PATH, 'vcshgclone%s' % uniq_suffix)

TEST_HG_REPO_PULL = jn(TESTS_TMP_PATH, 'vcshgpull%s' % uniq_suffix)

TEST_DIR = tempfile.gettempdir()

TEST_REPO_PREFIX = 'vcs-test'

# cached repos if any !

# comment out to get some other repos from bb or github

GIT_REMOTE_REPO = jn(TESTS_TMP_PATH, GIT_REPO)

HG_REMOTE_REPO = jn(TESTS_TMP_PATH, HG_REPO)

#skip ldap tests if LDAP lib is not installed

ldap_lib_installed = False

try:

    import ldap

    ldap.API_VERSION

    ldap_lib_installed = True

except ImportError:

    # means that python-ldap is not installed

    pass

try:

    import pam

    pam.PAM_TEXT_INFO

    pam_lib_installed = True

except ImportError:

    pam_lib_installed = False

class NullHandler(logging.Handler):

    def emit(self, record):

        pass

    """Pytest-style test controller"""

    # Note: pytest base classes cannot have an __init__ method

    @pytest.fixture(autouse=True)

    def app_fixture(self):

        self.wsgiapp = pylons.test.pylonsapp

        self.init_stack(self.wsgiapp.config)

        self.app = TestApp(self.wsgiapp)

        self.maxDiff = None

        self.index_location = config['app_conf']['index_dir']

        return self.app

    def init_stack(self, config=None):

        if not config:

            config = pylons.test.pylonsapp.config

        url._push_object(URLGenerator(config['routes.map'], environ))

        pylons.app_globals._push_object(config['pylons.app_globals'])

        pylons.config._push_object(config)

        pylons.tmpl_context._push_object(ContextObj())

        # Initialize a translator for tests that utilize i18n

        translator = _get_translator(pylons.config.get('lang'))

        pylons.translator._push_object(translator)

        h = NullHandler()

        logging.getLogger("kallithea").addHandler(h)

    def remove_all_notifications(self):

        Notification.query().delete()

        # Because query().delete() does not (by default) trigger cascades.

        # http://docs.sqlalchemy.org/en/rel_0_7/orm/collections.html#passive-deletes

        UserNotification.query().delete()

        Session().commit()

    def log_user(self, username=TEST_USER_ADMIN_LOGIN,

                 password=TEST_USER_ADMIN_PASS):

        self._logged_username = username

        response = self.app.post(url(controller='login', action='index'),

                                 {'username': username,

                                  'password': password})

        if 'Invalid username or password' in response.body:

            pytest.fail('could not login using %s %s' % (username, password))

        assert response.status == '302 Found'

        self.assert_authenticated_user(response, username)

        response = response.follow()

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from kallithea.tests.api.api_base import _BaseTestApi

    REPO = GIT_REPO

    REPO_TYPE = 'git'

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# 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 General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from kallithea.tests.api.api_base import _BaseTestApi

    REPO = HG_REPO

    REPO_TYPE = 'hg'

import os

import csv

import datetime

from kallithea.tests import *

from kallithea.model.db import UserLog

from kallithea.model.meta import Session

from kallithea.lib.utils2 import safe_unicode

dn = os.path.dirname

FIXTURES = os.path.join(dn(dn(os.path.abspath(__file__))), 'fixtures')

    @classmethod

    def setup_class(cls):

        UserLog.query().delete()

        Session().commit()

        def strptime(val):

            fmt = '%Y-%m-%d %H:%M:%S'

            if '.' not in val:

                return datetime.datetime.strptime(val, fmt)

            nofrag, frag = val.split(".")

            date = datetime.datetime.strptime(nofrag, fmt)

            frag = frag[:6]  # truncate to microseconds

            frag += (6 - len(frag)) * '0'  # add 0s

            return date.replace(microsecond=int(frag))

        with open(os.path.join(FIXTURES, 'journal_dump.csv')) as f:

            for row in csv.DictReader(f):

                ul = UserLog()

                for k, v in row.iteritems():

                    v = safe_unicode(v)

                    if k == 'action_date':

                        v = strptime(v)

                    if k in ['user_id', 'repository_id']:

                        # nullable due to FK problems

                        v = None

                    setattr(ul, k, v)

                Session().add(ul)

            Session().commit()

    @classmethod

    def teardown_class(cls):

        UserLog.query().delete()

        Session().commit()

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index'))

        response.mustcontain('Admin Journal')

    def test_filter_all_entries(self):

        self.log_user()

        response = self.app.get(url(controller='admin/admin', action='index',))

        response.mustcontain('2034 Entries')

    def test_filter_journal_filter_exact_match_on_repository(self):

from kallithea.tests import *

from kallithea.model.db import Setting

    def _enable_plugins(self, plugins_list):

        test_url = url(controller='admin/auth_settings',

                       action='auth_settings')

        params={'auth_plugins': plugins_list, '_authentication_token': self.authentication_token()}

        for plugin in plugins_list.split(','):

            enable = plugin.partition('kallithea.lib.auth_modules.')[-1]

            params.update({'%s_enabled' % enable: True})

        response = self.app.post(url=test_url, params=params)

        return params

        #self.checkSessionFlash(response, 'Auth settings updated successfully')

    def test_index(self):

        self.log_user()

        response = self.app.get(url(controller='admin/auth_settings',

                                    action='index'))

        response.mustcontain('Authentication Plugins')

    @skipif(not ldap_lib_installed, reason='skipping due to missing ldap lib')

    def test_ldap_save_settings(self):

        self.log_user()

        params = self._enable_plugins('kallithea.lib.auth_modules.auth_internal,kallithea.lib.auth_modules.auth_ldap')

        params.update({'auth_ldap_host': u'dc.example.com',

                       'auth_ldap_port': '999',

                       'auth_ldap_tls_kind': 'PLAIN',

                       'auth_ldap_tls_reqcert': 'NEVER',

                       'auth_ldap_dn_user': 'test_user',

                       'auth_ldap_dn_pass': 'test_pass',

                       'auth_ldap_base_dn': 'test_base_dn',

                       'auth_ldap_filter': 'test_filter',

                       'auth_ldap_search_scope': 'BASE',

                       'auth_ldap_attr_login': 'test_attr_login',

                       'auth_ldap_attr_firstname': 'ima',

                       'auth_ldap_attr_lastname': 'tester',

                       'auth_ldap_attr_email': 'test@example.com'})

        test_url = url(controller='admin/auth_settings',

                       action='auth_settings')

        response = self.app.post(url=test_url, params=params)

        self.checkSessionFlash(response, 'Auth settings updated successfully')

        new_settings = Setting.get_auth_settings()

        assert new_settings['auth_ldap_host'] == u'dc.example.com', 'fail db write compare'

    @skipif(not ldap_lib_installed, reason='skipping due to missing ldap lib')

    def test_ldap_error_form_wrong_port_number(self):

from kallithea.tests import *

from kallithea.model.db import Setting

    def test_index(self):

        self.log_user()

        response = self.app.get(url('defaults'))

        response.mustcontain('default_repo_private')

        response.mustcontain('default_repo_enable_statistics')

        response.mustcontain('default_repo_enable_downloads')

        response.mustcontain('default_repo_enable_locking')

    def test_index_as_xml(self):

        response = self.app.get(url('formatted_defaults', format='xml'))

    def test_create(self):

        response = self.app.post(url('defaults'),

            {'_authentication_token': self.authentication_token()})

    def test_new(self):

        response = self.app.get(url('new_default'))

    def test_new_as_xml(self):

        response = self.app.get(url('formatted_new_default', format='xml'))

    def test_update_params_true_hg(self):

        self.log_user()

        params = {

            'default_repo_enable_locking': True,

            'default_repo_enable_downloads': True,

            'default_repo_enable_statistics': True,

            'default_repo_private': True,

            'default_repo_type': 'hg',

            '_authentication_token': self.authentication_token(),

        }

        response = self.app.put(url('default', id='default'), params=params)

        self.checkSessionFlash(response, 'Default settings updated successfully')

        params.pop('_authentication_token')

        defs = Setting.get_default_repo_settings()

        assert params == defs

    def test_update_params_false_git(self):

        self.log_user()

        params = {

            'default_repo_enable_locking': False,

            'default_repo_enable_downloads': False,

            'default_repo_enable_statistics': False,

            'default_repo_private': False,

            'default_repo_type': 'git',

            '_authentication_token': self.authentication_token(),

from kallithea.tests import *

from kallithea.model.gist import GistModel

from kallithea.model.meta import Session

from kallithea.model.db import User, Gist

def _create_gist(f_name, content='some gist', lifetime=-1,

                 description=u'gist-desc', gist_type='public',

                 owner=TEST_USER_ADMIN_LOGIN):

    gist_mapping = {

        f_name: {'content': content}

    }

    user = User.get_by_username(owner)

    gist = GistModel().create(description, owner=user,

                       gist_mapping=gist_mapping, gist_type=gist_type,

                       lifetime=lifetime)

    Session().commit()

    return gist

    def teardown_method(self, method):

        for g in Gist.get_all():

            GistModel().delete(g)

        Session().commit()

    def test_index(self):

        self.log_user()

        response = self.app.get(url('gists'))

        # Test response...

        response.mustcontain('There are no gists yet')

        g1 = _create_gist('gist1').gist_access_id

        g2 = _create_gist('gist2', lifetime=1400).gist_access_id

        g3 = _create_gist('gist3', description=u'gist3-desc').gist_access_id

        g4 = _create_gist('gist4', gist_type='private').gist_access_id

        response = self.app.get(url('gists'))

        # Test response...

        response.mustcontain('gist: %s' % g1)

        response.mustcontain('gist: %s' % g2)

        response.mustcontain('Expires: in 23 hours')  # we don't care about the end

        response.mustcontain('gist: %s' % g3)

        response.mustcontain('gist3-desc')

        response.mustcontain(no=['gist: %s' % g4])

    def test_index_private_gists(self):

        self.log_user()

        gist = _create_gist('gist5', gist_type='private')

        response = self.app.get(url('gists', private=1))

        # Test response...

        #and privates

        response.mustcontain('gist: %s' % gist.gist_access_id)

    def test_create_missing_description(self):

        self.log_user()

        response = self.app.post(url('gists'),

                                 params={'lifetime': -1, '_authentication_token': self.authentication_token()},

                                 status=200)

        response.mustcontain('Missing value')

    def test_create(self):

        self.log_user()

        response = self.app.post(url('gists'),

                                 params={'lifetime': -1,

                                         'content': 'gist test',

                                         'filename': 'foo',

from kallithea.tests import *

from kallithea.model.db import User

from kallithea.model.user import UserModel

from kallithea.model.notification import NotificationModel

from kallithea.model.meta import Session

from kallithea.lib import helpers as h

    def setup_method(self, method):

        self.remove_all_notifications()

    def test_index(self):

        self.log_user()

        u1 = UserModel().create_or_update(username='u1', password='qweqwe',

                                          email='u1@example.com',

                                          firstname=u'u1', lastname=u'u1')

        u1 = u1.user_id

        Session().commit()

        response = self.app.get(url('notifications'))

        response.mustcontain('<div class="table">No notifications here yet</div>')

        cur_user = self._get_logged_user()

        notif = NotificationModel().create(created_by=u1, subject=u'test_notification_1',

                                           body=u'notification_1', recipients=[cur_user])

        Session().commit()

        response = self.app.get(url('notifications'))

        response.mustcontain('id="notification_%s"' % notif.notification_id)

    def test_delete(self):

        self.log_user()

        cur_user = self._get_logged_user()

        u1 = UserModel().create_or_update(username='u1', password='qweqwe',

                                               email='u1@example.com',

                                               firstname=u'u1', lastname=u'u1')

        u2 = UserModel().create_or_update(username='u2', password='qweqwe',

                                               email='u2@example.com',

                                               firstname=u'u2', lastname=u'u2')

        # make notifications

        notification = NotificationModel().create(created_by=cur_user,

                                                  subject=u'test',

                                                  body=u'hi there',

                                                  recipients=[cur_user, u1, u2])

        Session().commit()

        u1 = User.get(u1.user_id)

        u2 = User.get(u2.user_id)

        # check DB

        get_notif = lambda un: [x.notification for x in un]

        assert get_notif(cur_user.notifications) == [notification]

        assert get_notif(u1.notifications) == [notification]

        assert get_notif(u2.notifications) == [notification]

        cur_usr_id = cur_user.user_id

import time

from kallithea.model.db import User, UserIpMap

from kallithea.tests import *

    def test_index(self):

        self.log_user()

        response = self.app.get(url('admin_permissions'))

        # Test response...

    def test_index_ips(self):

        self.log_user()

        response = self.app.get(url('admin_permissions_ips'))

        # Test response...

        response.mustcontain('All IP addresses are allowed')

    def test_add_ips(self):

        self.log_user()

        default_user_id = User.get_default_user().user_id

        response = self.app.put(url('edit_user_ips', id=default_user_id),

                                 params=dict(new_ip='127.0.0.0/24',

                                 _authentication_token=self.authentication_token()))

        # sleep more than beaker.cache.sql_cache_short.expire to expire user cache

        time.sleep(1.5)

        self.app.get(url('admin_permissions_ips'), status=302)

        # REMOTE_ADDR must match 127.0.0.0/24

        response = self.app.get(url('admin_permissions_ips'),

                                extra_environ={'REMOTE_ADDR': '127.0.0.1'})

        response.mustcontain('127.0.0.0/24')

        response.mustcontain('127.0.0.0 - 127.0.0.255')

        ## delete

        default_user_id = User.get_default_user().user_id

        del_ip_id = UserIpMap.query().filter(UserIpMap.user_id ==

                                             default_user_id).first().ip_id

        response = self.app.post(url('edit_user_ips', id=default_user_id),

                                 params=dict(_method='delete',

                                             del_ip_id=del_ip_id,

                                             _authentication_token=self.authentication_token()),

                                 extra_environ={'REMOTE_ADDR': '127.0.0.1'})

        # sleep more than beaker.cache.sql_cache_short.expire to expire user cache

        time.sleep(1.5)

        response = self.app.get(url('admin_permissions_ips'))

        response.mustcontain('All IP addresses are allowed')

        response.mustcontain(no=['127.0.0.0/24'])

        response.mustcontain(no=['127.0.0.0 - 127.0.0.255'])

from kallithea.tests import *

    pass

# -*- coding: utf-8 -*-

import os

import mock

import urllib

from kallithea.lib import vcs

from kallithea.lib.utils2 import safe_str, safe_unicode

from kallithea.model.db import Repository, RepoGroup, UserRepoToPerm, User, \

    Permission, Ui

from kallithea.model.user import UserModel

from kallithea.tests import *

from kallithea.model.repo_group import RepoGroupModel

from kallithea.model.repo import RepoModel

from kallithea.model.meta import Session

from kallithea.tests.fixture import Fixture, error_function

fixture = Fixture()

def _get_permission_for_user(user, repo):

    perm = UserRepoToPerm.query() \

                .filter(UserRepoToPerm.repository ==

                        Repository.get_by_repo_name(repo)) \

                .filter(UserRepoToPerm.user == User.get_by_username(user)) \

                .all()

    return perm

    """

    Write all tests here

    """

    REPO = None

    REPO_TYPE = None

    NEW_REPO = None

    OTHER_TYPE_REPO = None

    OTHER_TYPE = None

    def test_index(self):

        self.log_user()

        response = self.app.get(url('repos'))

    def test_create(self):

        self.log_user()

        repo_name = self.NEW_REPO

        description = u'description for newly created repo'

        response = self.app.post(url('repos'),

                        fixture._get_repo_create_params(repo_private=False,

                                                repo_name=repo_name,

                                                repo_type=self.REPO_TYPE,

                                                repo_description=description,

                                                _authentication_token=self.authentication_token()))

        ## run the check page that triggers the flash message

        response = self.app.get(url('repo_check_home', repo_name=repo_name))

        assert response.json == {u'result': True}

        self.checkSessionFlash(response,

                               'Created repository <a href="/%s">%s</a>'

                               % (repo_name, repo_name))

        # test if the repo was created in the database

        new_repo = Session().query(Repository) \

            .filter(Repository.repo_name == repo_name).one()

        assert new_repo.repo_name == repo_name

        assert new_repo.description == description

        # test if the repository is visible in the list ?

        response = self.app.get(url('summary_home', repo_name=repo_name))

        response.mustcontain(repo_name)

        response.mustcontain(self.REPO_TYPE)

        # test if the repository was created on filesystem

        try:

            vcs.get_repo(safe_str(os.path.join(Ui.get_by_key('paths', '/').ui_value, repo_name)))

        except vcs.exceptions.VCSError:

            pytest.fail('no repo %s in filesystem' % repo_name)

# -*- coding: utf-8 -*-

import tempfile

from kallithea.model.db import Setting, Ui

from kallithea.tests import *

from kallithea.tests.fixture import Fixture

fixture = Fixture()

    def test_index_main(self):

        self.log_user()

        response = self.app.get(url('admin_settings'))

    def test_index_mapping(self):

        self.log_user()

        response = self.app.get(url('admin_settings_mapping'))

    def test_index_global(self):

        self.log_user()

        response = self.app.get(url('admin_settings_global'))

    def test_index_visual(self):

        self.log_user()

        response = self.app.get(url('admin_settings_visual'))

    def test_index_email(self):

        self.log_user()

        response = self.app.get(url('admin_settings_email'))

    def test_index_hooks(self):

        self.log_user()

        response = self.app.get(url('admin_settings_hooks'))

    def test_create_custom_hook(self):

        self.log_user()

        response = self.app.post(url('admin_settings_hooks'),

                                params=dict(new_hook_ui_key='test_hooks_1',

                                            new_hook_ui_value='cd %s' % tempfile.gettempdir(),

                                            _authentication_token=self.authentication_token()))

        response = response.follow()

        response.mustcontain('test_hooks_1')

        response.mustcontain('cd %s' % tempfile.gettempdir())

    def test_create_custom_hook_delete(self):

        self.log_user()

        response = self.app.post(url('admin_settings_hooks'),

                                params=dict(new_hook_ui_key='test_hooks_2',

                                            new_hook_ui_value='cd %s2' % tempfile.gettempdir(),

                                            _authentication_token=self.authentication_token()))

        response = response.follow()

        response.mustcontain('test_hooks_2')

        response.mustcontain('cd %s2' % tempfile.gettempdir())

        hook_id = Ui.get_by_key('hooks', 'test_hooks_2').ui_id

# -*- coding: utf-8 -*-

from kallithea.tests import *

from kallithea.model.db import UserGroup, UserGroupToPerm, Permission

from kallithea.model.meta import Session

TEST_USER_GROUP = u'admins_test'

    def test_index(self):

        self.log_user()

        response = self.app.get(url('users_groups'))

        # Test response...

    def test_create(self):

        self.log_user()

        users_group_name = TEST_USER_GROUP

        response = self.app.post(url('users_groups'),

                                 {'users_group_name': users_group_name,

                                  'user_group_description': u'DESC',

                                  'active': True,

                                  '_authentication_token': self.authentication_token()})

        response.follow()

        self.checkSessionFlash(response,

                               'Created user group <a href="/_admin/user_groups/')

        self.checkSessionFlash(response,

                               '/edit">%s</a>' % TEST_USER_GROUP)

    def test_new(self):

        response = self.app.get(url('new_users_group'))

    def test_update(self):

        response = self.app.put(url('users_group', id=1), status=403)

    def test_update_browser_fakeout(self):

        response = self.app.post(url('users_group', id=1),

                                 params=dict(_method='put', _authentication_token=self.authentication_token()))

    def test_delete(self):

        self.log_user()

        users_group_name = TEST_USER_GROUP + 'another'

        response = self.app.post(url('users_groups'),

                                 {'users_group_name':users_group_name,

                                  'user_group_description': u'DESC',

                                  'active': True,

                                  '_authentication_token': self.authentication_token()})

        response.follow()

        self.checkSessionFlash(response,

                               'Created user group ')

        gr = Session().query(UserGroup) \

            .filter(UserGroup.users_group_name == users_group_name).one()

        response = self.app.post(url('users_group', id=gr.users_group_id),

# -*- coding: utf-8 -*-

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.