tests: fix usage of false in test, in forms it's always with capital letter.

rhodecode/lib/db_manage.py

@@ -1,611 +1,611 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Database creation, and setup module for RhodeCode Enterprise. Used for creation
 of database as well as for migration operations
 """
 
 import os
 import sys
 import time
 import uuid
 import logging
 import getpass
 from os.path import dirname as dn, join as jn
 
 from sqlalchemy.engine import create_engine
 
 from rhodecode import __dbversion__
 from rhodecode.model import init_model
 from rhodecode.model.user import UserModel
 from rhodecode.model.db import (
     User, Permission, RhodeCodeUi, RhodeCodeSetting, UserToPerm,
     DbMigrateVersion, RepoGroup, UserRepoGroupToPerm, CacheKey, Repository)
 from rhodecode.model.meta import Session, Base
 from rhodecode.model.permission import PermissionModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.settings import SettingsModel
 
 
 log = logging.getLogger(__name__)
 
 
 def notify(msg):
     """
     Notification for migrations messages
     """
     ml = len(msg) + (4 * 2)
     print('\n%s\n*** %s ***\n%s' % ('*' * ml, msg, '*' * ml)).upper()
 
 
 class DbManage(object):
 
     def __init__(self, log_sql, dbconf, root, tests=False,
                  SESSION=None, cli_args={}):
         self.dbname = dbconf.split('/')[-1]
         self.tests = tests
         self.root = root
         self.dburi = dbconf
         self.log_sql = log_sql
         self.db_exists = False
         self.cli_args = cli_args
         self.init_db(SESSION=SESSION)
         self.ask_ok = self.get_ask_ok_func(self.cli_args.get('force_ask'))
 
     def get_ask_ok_func(self, param):
         if param not in [None]:
             # return a function lambda that has a default set to param
             return lambda *args, **kwargs: param
         else:
             from rhodecode.lib.utils import ask_ok
             return ask_ok
 
     def init_db(self, SESSION=None):
         if SESSION:
             self.sa = SESSION
         else:
             # init new sessions
             engine = create_engine(self.dburi, echo=self.log_sql)
             init_model(engine)
             self.sa = Session()
 
     def create_tables(self, override=False):
         """
         Create a auth database
         """
 
         log.info("Existing database with the same name is going to be destroyed.")
         log.info("Setup command will run DROP ALL command on that database.")
         if self.tests:
             destroy = True
         else:
             destroy = self.ask_ok('Are you sure that you want to destroy the old database? [y/n]')
         if not destroy:
             log.info('Nothing done.')
             sys.exit(0)
         if destroy:
             Base.metadata.drop_all()
 
         checkfirst = not override
         Base.metadata.create_all(checkfirst=checkfirst)
         log.info('Created tables for %s' % self.dbname)
 
     def set_db_version(self):
         ver = DbMigrateVersion()
         ver.version = __dbversion__
         ver.repository_id = 'rhodecode_db_migrations'
         ver.repository_path = 'versions'
         self.sa.add(ver)
         log.info('db version set to: %s' % __dbversion__)
 
     def run_pre_migration_tasks(self):
         """
         Run various tasks before actually doing migrations
         """
         # delete cache keys on each upgrade
         total = CacheKey.query().count()
         log.info("Deleting (%s) cache keys now...", total)
         CacheKey.delete_all_cache()
 
     def upgrade(self):
         """
         Upgrades given database schema to given revision following
         all needed steps, to perform the upgrade
 
         """
 
         from rhodecode.lib.dbmigrate.migrate.versioning import api
         from rhodecode.lib.dbmigrate.migrate.exceptions import \
             DatabaseNotControlledError
 
         if 'sqlite' in self.dburi:
             print (
                '********************** WARNING **********************\n'
                'Make sure your version of sqlite is at least 3.7.X.  \n'
                'Earlier versions are known to fail on some migrations\n'
                '*****************************************************\n')
 
         upgrade = self.ask_ok(
             'You are about to perform a database upgrade. Make '
             'sure you have backed up your database. '
             'Continue ? [y/n]')
         if not upgrade:
             log.info('No upgrade performed')
             sys.exit(0)
 
         repository_path = jn(dn(dn(dn(os.path.realpath(__file__)))),
                              'rhodecode/lib/dbmigrate')
         db_uri = self.dburi
 
         try:
             curr_version = api.db_version(db_uri, repository_path)
             msg = ('Found current database under version '
                    'control with version %s' % curr_version)
 
         except (RuntimeError, DatabaseNotControlledError):
             curr_version = 1
             msg = ('Current database is not under version control. Setting '
                    'as version %s' % curr_version)
             api.version_control(db_uri, repository_path, curr_version)
 
         notify(msg)
 
         self.run_pre_migration_tasks()
 
         if curr_version == __dbversion__:
             log.info('This database is already at the newest version')
             sys.exit(0)
 
         upgrade_steps = range(curr_version + 1, __dbversion__ + 1)
         notify('attempting to upgrade database from '
                'version %s to version %s' % (curr_version, __dbversion__))
 
         # CALL THE PROPER ORDER OF STEPS TO PERFORM FULL UPGRADE
         _step = None
         for step in upgrade_steps:
             notify('performing upgrade step %s' % step)
             time.sleep(0.5)
 
             api.upgrade(db_uri, repository_path, step)
             self.sa.rollback()
             notify('schema upgrade for step %s completed' % (step,))
 
             _step = step
 
         notify('upgrade to version %s successful' % _step)
 
     def fix_repo_paths(self):
         """
         Fixes an old RhodeCode version path into new one without a '*'
         """
 
         paths = self.sa.query(RhodeCodeUi)\
                 .filter(RhodeCodeUi.ui_key == '/')\
                 .scalar()
 
         paths.ui_value = paths.ui_value.replace('*', '')
 
         try:
             self.sa.add(paths)
             self.sa.commit()
         except Exception:
             self.sa.rollback()
             raise
 
     def fix_default_user(self):
         """
         Fixes an old default user with some 'nicer' default values,
         used mostly for anonymous access
         """
         def_user = self.sa.query(User)\
                 .filter(User.username == User.DEFAULT_USER)\
                 .one()
 
         def_user.name = 'Anonymous'
         def_user.lastname = 'User'
         def_user.email = User.DEFAULT_USER_EMAIL
 
         try:
             self.sa.add(def_user)
             self.sa.commit()
         except Exception:
             self.sa.rollback()
             raise
 
     def fix_settings(self):
         """
         Fixes rhodecode settings and adds ga_code key for google analytics
         """
 
         hgsettings3 = RhodeCodeSetting('ga_code', '')
 
         try:
             self.sa.add(hgsettings3)
             self.sa.commit()
         except Exception:
             self.sa.rollback()
             raise
 
     def create_admin_and_prompt(self):
 
         # defaults
         defaults = self.cli_args
         username = defaults.get('username')
         password = defaults.get('password')
         email = defaults.get('email')
 
         if username is None:
             username = raw_input('Specify admin username:')
         if password is None:
             password = self._get_admin_password()
             if not password:
                 # second try
                 password = self._get_admin_password()
                 if not password:
                     sys.exit()
         if email is None:
             email = raw_input('Specify admin email:')
         api_key = self.cli_args.get('api_key')
         self.create_user(username, password, email, True,
                          strict_creation_check=False,
                          api_key=api_key)
 
     def _get_admin_password(self):
         password = getpass.getpass('Specify admin password '
                                    '(min 6 chars):')
         confirm = getpass.getpass('Confirm password:')
 
         if password != confirm:
             log.error('passwords mismatch')
             return False
         if len(password) < 6:
             log.error('password is too short - use at least 6 characters')
             return False
 
         return password
 
     def create_test_admin_and_users(self):
         log.info('creating admin and regular test users')
         from rhodecode.tests import 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
 
         self.create_user(TEST_USER_ADMIN_LOGIN, TEST_USER_ADMIN_PASS,
                          TEST_USER_ADMIN_EMAIL, True, api_key=True)
 
         self.create_user(TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS,
                          TEST_USER_REGULAR_EMAIL, False, api_key=True)
 
         self.create_user(TEST_USER_REGULAR2_LOGIN, TEST_USER_REGULAR2_PASS,
                          TEST_USER_REGULAR2_EMAIL, False, api_key=True)
 
     def create_ui_settings(self, repo_store_path):
         """
         Creates ui settings, fills out hooks
         and disables dotencode
         """
         settings_model = SettingsModel(sa=self.sa)
         from rhodecode.lib.vcs.backends.hg import largefiles_store
         from rhodecode.lib.vcs.backends.git import lfs_store
 
         # Build HOOKS
         hooks = [
             (RhodeCodeUi.HOOK_REPO_SIZE, 'python:vcsserver.hooks.repo_size'),
 
             # HG
             (RhodeCodeUi.HOOK_PRE_PULL, 'python:vcsserver.hooks.pre_pull'),
             (RhodeCodeUi.HOOK_PULL, 'python:vcsserver.hooks.log_pull_action'),
             (RhodeCodeUi.HOOK_PRE_PUSH, 'python:vcsserver.hooks.pre_push'),
             (RhodeCodeUi.HOOK_PRETX_PUSH, 'python:vcsserver.hooks.pre_push'),
             (RhodeCodeUi.HOOK_PUSH, 'python:vcsserver.hooks.log_push_action'),
 
         ]
 
         for key, value in hooks:
             hook_obj = settings_model.get_ui_by_key(key)
             hooks2 = hook_obj if hook_obj else RhodeCodeUi()
             hooks2.ui_section = 'hooks'
             hooks2.ui_key = key
             hooks2.ui_value = value
             self.sa.add(hooks2)
 
         # enable largefiles
         largefiles = RhodeCodeUi()
         largefiles.ui_section = 'extensions'
         largefiles.ui_key = 'largefiles'
         largefiles.ui_value = ''
         self.sa.add(largefiles)
 
         # set default largefiles cache dir, defaults to
         # /repo_store_location/.cache/largefiles
         largefiles = RhodeCodeUi()
         largefiles.ui_section = 'largefiles'
         largefiles.ui_key = 'usercache'
         largefiles.ui_value = largefiles_store(repo_store_path)
 
         self.sa.add(largefiles)
 
         # set default lfs cache dir, defaults to
         # /repo_store_location/.cache/lfs_store
         lfsstore = RhodeCodeUi()
         lfsstore.ui_section = 'vcs_git_lfs'
         lfsstore.ui_key = 'store_location'
         lfsstore.ui_value = lfs_store(repo_store_path)
 
         self.sa.add(lfsstore)
 
         # enable hgsubversion disabled by default
         hgsubversion = RhodeCodeUi()
         hgsubversion.ui_section = 'extensions'
         hgsubversion.ui_key = 'hgsubversion'
         hgsubversion.ui_value = ''
         hgsubversion.ui_active = False
         self.sa.add(hgsubversion)
 
         # enable hggit disabled by default
         hggit = RhodeCodeUi()
         hggit.ui_section = 'extensions'
         hggit.ui_key = 'hggit'
         hggit.ui_value = ''
         hggit.ui_active = False
         self.sa.add(hggit)
 
         # set svn branch defaults
         branches = ["/branches/*", "/trunk"]
         tags = ["/tags/*"]
 
         for branch in branches:
             settings_model.create_ui_section_value(
                 RhodeCodeUi.SVN_BRANCH_ID, branch)
 
         for tag in tags:
             settings_model.create_ui_section_value(RhodeCodeUi.SVN_TAG_ID, tag)
 
     def create_auth_plugin_options(self, skip_existing=False):
         """
         Create default auth plugin settings, and make it active
 
         :param skip_existing:
         """
 
         for k, v, t in [('auth_plugins', 'egg:rhodecode-enterprise-ce#rhodecode', 'list'),
                         ('auth_rhodecode_enabled', 'True', 'bool')]:
             if (skip_existing and
                     SettingsModel().get_setting_by_name(k) is not None):
                 log.debug('Skipping option %s' % k)
                 continue
             setting = RhodeCodeSetting(k, v, t)
             self.sa.add(setting)
 
     def create_default_options(self, skip_existing=False):
         """Creates default settings"""
 
         for k, v, t in [
             ('default_repo_enable_locking',  False, 'bool'),
             ('default_repo_enable_downloads', False, 'bool'),
             ('default_repo_enable_statistics', False, 'bool'),
             ('default_repo_private', False, 'bool'),
             ('default_repo_type', 'hg', 'unicode')]:
 
             if (skip_existing and
                     SettingsModel().get_setting_by_name(k) is not None):
                 log.debug('Skipping option %s' % k)
                 continue
             setting = RhodeCodeSetting(k, v, t)
             self.sa.add(setting)
 
     def fixup_groups(self):
         def_usr = User.get_default_user()
         for g in RepoGroup.query().all():
             g.group_name = g.get_new_name(g.name)
             self.sa.add(g)
             # get default perm
             default = UserRepoGroupToPerm.query()\
                 .filter(UserRepoGroupToPerm.group == g)\
                 .filter(UserRepoGroupToPerm.user == def_usr)\
                 .scalar()
 
             if default is None:
                 log.debug('missing default permission for group %s adding' % g)
                 perm_obj = RepoGroupModel()._create_default_perms(g)
                 self.sa.add(perm_obj)
 
     def reset_permissions(self, username):
         """
         Resets permissions to default state, useful when old systems had
         bad permissions, we must clean them up
 
         :param username:
         """
         default_user = User.get_by_username(username)
         if not default_user:
             return
 
         u2p = UserToPerm.query()\
             .filter(UserToPerm.user == default_user).all()
         fixed = False
         if len(u2p) != len(Permission.DEFAULT_USER_PERMISSIONS):
             for p in u2p:
                 Session().delete(p)
             fixed = True
             self.populate_default_permissions()
         return fixed
 
     def update_repo_info(self):
         RepoModel.update_repoinfo()
 
     def config_prompt(self, test_repo_path='', retries=3):
         defaults = self.cli_args
         _path = defaults.get('repos_location')
         if retries == 3:
             log.info('Setting up repositories config')
 
         if _path is not None:
             path = _path
         elif not self.tests and not test_repo_path:
             path = raw_input(
                  'Enter a valid absolute path to store repositories. '
                  'All repositories in that path will be added automatically:'
             )
         else:
             path = test_repo_path
         path_ok = True
 
         # check proper dir
         if not os.path.isdir(path):
             path_ok = False
             log.error('Given path %s is not a valid directory' % (path,))
 
         elif not os.path.isabs(path):
             path_ok = False
             log.error('Given path %s is not an absolute path' % (path,))
 
         # check if path is at least readable.
         if not os.access(path, os.R_OK):
             path_ok = False
             log.error('Given path %s is not readable' % (path,))
 
         # check write access, warn user about non writeable paths
         elif not os.access(path, os.W_OK) and path_ok:
             log.warning('No write permission to given path %s' % (path,))
 
             q = ('Given path %s is not writeable, do you want to '
                  'continue with read only mode ? [y/n]' % (path,))
             if not self.ask_ok(q):
                 log.error('Canceled by user')
                 sys.exit(-1)
 
         if retries == 0:
             sys.exit('max retries reached')
         if not path_ok:
             retries -= 1
             return self.config_prompt(test_repo_path, retries)
 
         real_path = os.path.normpath(os.path.realpath(path))
 
         if real_path != os.path.normpath(path):
             q = ('Path looks like a symlink, RhodeCode Enterprise will store '
                  'given path as %s ? [y/n]') % (real_path,)
             if not self.ask_ok(q):
                 log.error('Canceled by user')
                 sys.exit(-1)
 
         return real_path
 
     def create_settings(self, path):
 
         self.create_ui_settings(path)
 
         ui_config = [
-            ('web', 'push_ssl', 'false'),
+            ('web', 'push_ssl', 'False'),
             ('web', 'allow_archive', 'gz zip bz2'),
             ('web', 'allow_push', '*'),
             ('web', 'baseurl', '/'),
             ('paths', '/', path),
-            ('phases', 'publish', 'true')
+            ('phases', 'publish', 'True')
         ]
         for section, key, value in ui_config:
             ui_conf = RhodeCodeUi()
             setattr(ui_conf, 'ui_section', section)
             setattr(ui_conf, 'ui_key', key)
             setattr(ui_conf, 'ui_value', value)
             self.sa.add(ui_conf)
 
         # rhodecode app settings
         settings = [
             ('realm', 'RhodeCode', 'unicode'),
             ('title', '', 'unicode'),
             ('pre_code', '', 'unicode'),
             ('post_code', '', 'unicode'),
             ('show_public_icon', True, 'bool'),
             ('show_private_icon', True, 'bool'),
             ('stylify_metatags', False, 'bool'),
             ('dashboard_items', 100, 'int'),
             ('admin_grid_items', 25, 'int'),
             ('show_version', True, 'bool'),
             ('use_gravatar', False, 'bool'),
             ('gravatar_url', User.DEFAULT_GRAVATAR_URL, 'unicode'),
             ('clone_uri_tmpl', Repository.DEFAULT_CLONE_URI, 'unicode'),
             ('support_url', '', 'unicode'),
             ('update_url', RhodeCodeSetting.DEFAULT_UPDATE_URL, 'unicode'),
             ('show_revision_number', True, 'bool'),
             ('show_sha_length', 12, 'int'),
         ]
 
         for key, val, type_ in settings:
             sett = RhodeCodeSetting(key, val, type_)
             self.sa.add(sett)
 
         self.create_auth_plugin_options()
         self.create_default_options()
 
         log.info('created ui config')
 
     def create_user(self, username, password, email='', admin=False,
                     strict_creation_check=True, api_key=None):
         log.info('creating user %s' % username)
         user = UserModel().create_or_update(
             username, password, email, firstname='RhodeCode', lastname='Admin',
             active=True, admin=admin, extern_type="rhodecode",
             strict_creation_check=strict_creation_check)
 
         if api_key:
             log.info('setting a provided api key for the user %s', username)
             from rhodecode.model.auth_token import AuthTokenModel
             AuthTokenModel().create(
                 user=user, description='BUILTIN TOKEN')
 
     def create_default_user(self):
         log.info('creating default user')
         # create default user for handling default permissions.
         user = UserModel().create_or_update(username=User.DEFAULT_USER,
                                             password=str(uuid.uuid1())[:20],
                                             email=User.DEFAULT_USER_EMAIL,
                                             firstname='Anonymous',
                                             lastname='User',
                                             strict_creation_check=False)
         # based on configuration options activate/deactive this user which
         # controlls anonymous access
         if self.cli_args.get('public_access') is False:
             log.info('Public access disabled')
             user.active = False
             Session().add(user)
             Session().commit()
 
     def create_permissions(self):
         """
         Creates all permissions defined in the system
         """
         # module.(access|create|change|delete)_[name]
         # module.(none|read|write|admin)
         log.info('creating permissions')
         PermissionModel(self.sa).create_permissions()
 
     def populate_default_permissions(self):
         """
         Populate default permissions. It will create only the default
         permissions that are missing, and not alter already defined ones
         """
         log.info('creating default user permissions')
         PermissionModel(self.sa).create_default_user_permissions(user=User.DEFAULT_USER)

rhodecode/tests/functional/test_admin_repos.py

@@ -1,1250 +1,1250 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import urllib
 
 import mock
 import pytest
 
 from rhodecode.lib import auth
 from rhodecode.lib.utils2 import safe_str, str2bool
 from rhodecode.lib.vcs.exceptions import RepositoryRequirementError
 from rhodecode.model.db import Repository, RepoGroup, UserRepoToPerm, User,\
     Permission
 from rhodecode.model.meta import Session
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.settings import SettingsModel, VcsSettingsModel
 from rhodecode.model.user import UserModel
 from rhodecode.tests import (
     login_user_session, url, assert_session_flash, TEST_USER_ADMIN_LOGIN,
     TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS, HG_REPO, GIT_REPO,
     logout_user_session)
 from rhodecode.tests.fixture import Fixture, error_function
 from rhodecode.tests.utils import AssertResponse, repo_on_filesystem
 
 fixture = Fixture()
 
 
 @pytest.mark.usefixtures("app")
 class TestAdminRepos:
 
     def test_index(self):
         self.app.get(url('repos'))
 
     def test_create_page_restricted(self, autologin_user, backend):
         with mock.patch('rhodecode.BACKENDS', {'git': 'git'}):
             response = self.app.get(url('new_repo'), status=200)
         assert_response = AssertResponse(response)
         element = assert_response.get_element('#repo_type')
         assert element.text_content() == '\ngit\n'
 
     def test_create_page_non_restricted(self, autologin_user, backend):
         response = self.app.get(url('new_repo'), status=200)
         assert_response = AssertResponse(response)
         assert_response.element_contains('#repo_type', 'git')
         assert_response.element_contains('#repo_type', 'svn')
         assert_response.element_contains('#repo_type', 'hg')
 
     @pytest.mark.parametrize("suffix", [u'', u''], ids=['', 'non-ascii'])
     def test_create(self, autologin_user, backend, suffix, csrf_token):
         repo_name_unicode = backend.new_repo_name(suffix=suffix)
         repo_name = repo_name_unicode.encode('utf8')
         description_unicode = u'description for newly created repo' + suffix
         description = description_unicode.encode('utf8')
         self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token),
             status=302
             )
 
         self.assert_repository_is_created_correctly(
             repo_name, description, backend)
 
     def test_create_numeric(self, autologin_user, backend, csrf_token):
         numeric_repo = '1234'
         repo_name = numeric_repo
         description = 'description for newly created repo' + numeric_repo
         self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         self.assert_repository_is_created_correctly(
             repo_name, description, backend)
 
     @pytest.mark.parametrize("suffix", [u'', u'ąćę'], ids=['', 'non-ascii'])
     def test_create_in_group(
             self, autologin_user, backend, suffix, csrf_token):
         # create GROUP
         group_name = 'sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
 
         repo_name = u'ingroup' + suffix
         repo_name_full = RepoGroup.url_sep().join(
             [group_name, repo_name])
         description = u'description for newly created repo'
         self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=safe_str(repo_name),
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup work to fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query().filter(
                 UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             Session().commit()
 
     def test_create_in_group_numeric(
             self, autologin_user, backend, csrf_token):
         # create GROUP
         group_name = 'sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
 
         repo_name = '12345'
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
         self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup work to fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query()\
                 .filter(UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             Session().commit()
 
     def test_create_in_group_without_needed_permissions(self, backend):
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         csrf_token = auth.get_csrf_token(session)
         # revoke
         user_model = UserModel()
         # disable fork and create on default user
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')
 
         # disable on regular user
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')
         Session().commit()
 
         # create GROUP
         group_name = 'reg_sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         Session().commit()
 
         group_name_allowed = 'reg_sometest_allowed_%s' % backend.alias
         gr_allowed = RepoGroupModel().create(
             group_name=group_name_allowed,
             group_description='test',
             owner=TEST_USER_REGULAR_LOGIN)
         Session().commit()
 
         repo_name = 'ingroup'
         description = '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=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 csrf_token=csrf_token))
 
         response.mustcontain('Invalid value')
 
         # user is allowed to create in this group
         repo_name = 'ingroup'
         repo_name_full = RepoGroup.url_sep().join(
             [group_name_allowed, repo_name])
         description = '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=backend.alias,
                 repo_description=description,
                 repo_group=gr_allowed.group_id,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup in pytest fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
 
             new_repo = RepoModel().get_by_repo_name(repo_name_full)
             inherited_perms = UserRepoToPerm.query().filter(
                 UserRepoToPerm.repository_id == new_repo.repo_id).all()
             assert len(inherited_perms) == 1
 
             assert repo_on_filesystem(repo_name_full)
         finally:
             RepoModel().delete(repo_name_full)
             RepoGroupModel().delete(group_name)
             RepoGroupModel().delete(group_name_allowed)
             Session().commit()
 
     def test_create_in_group_inherit_permissions(self, autologin_user, backend,
                                                  csrf_token):
         # create GROUP
         group_name = 'sometest_%s' % backend.alias
         gr = RepoGroupModel().create(group_name=group_name,
                                      group_description='test',
                                      owner=TEST_USER_ADMIN_LOGIN)
         perm = Permission.get_by_key('repository.write')
         RepoGroupModel().grant_user_permission(
             gr, TEST_USER_REGULAR_LOGIN, perm)
 
         # add repo permissions
         Session().commit()
 
         repo_name = 'ingroup_inherited_%s' % backend.alias
         repo_name_full = RepoGroup.url_sep().join([group_name, repo_name])
         description = 'description for newly created repo'
         self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description=description,
                 repo_group=gr.group_id,
                 repo_copy_permissions=True,
                 csrf_token=csrf_token))
 
         # TODO: johbo: Cleanup to pytest fixture
         try:
             self.assert_repository_is_created_correctly(
                 repo_name_full, description, backend)
         except Exception:
             RepoGroupModel().delete(group_name)
             Session().commit()
             raise
 
         # check if inherited permissions are applied
         new_repo = RepoModel().get_by_repo_name(repo_name_full)
         inherited_perms = UserRepoToPerm.query().filter(
             UserRepoToPerm.repository_id == new_repo.repo_id).all()
         assert len(inherited_perms) == 2
 
         assert TEST_USER_REGULAR_LOGIN in [
             x.user.username for x in inherited_perms]
         assert 'repository.write' in [
             x.permission.permission_name for x in inherited_perms]
 
         RepoModel().delete(repo_name_full)
         RepoGroupModel().delete(group_name)
         Session().commit()
 
     @pytest.mark.xfail_backends(
         "git", "hg", reason="Missing reposerver support")
     def test_create_with_clone_uri(self, autologin_user, backend, reposerver,
                                    csrf_token):
         source_repo = backend.create_repo(number_of_commits=2)
         source_repo_name = source_repo.repo_name
         reposerver.serve(source_repo.scm_instance())
 
         repo_name = backend.new_repo_name()
         response = self.app.post(
             url('repos'),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=repo_name,
                 repo_type=backend.alias,
                 repo_description='',
                 clone_uri=reposerver.url,
                 csrf_token=csrf_token),
             status=302)
 
         # Should be redirected to the creating page
         response.mustcontain('repo_creating')
 
         # Expecting that both repositories have same history
         source_repo = RepoModel().get_by_repo_name(source_repo_name)
         source_vcs = source_repo.scm_instance()
         repo = RepoModel().get_by_repo_name(repo_name)
         repo_vcs = repo.scm_instance()
         assert source_vcs[0].message == repo_vcs[0].message
         assert source_vcs.count() == repo_vcs.count()
         assert source_vcs.commit_ids == repo_vcs.commit_ids
 
     @pytest.mark.xfail_backends("svn", reason="Depends on import support")
     def test_create_remote_repo_wrong_clone_uri(self, autologin_user, backend,
                                                 csrf_token):
         repo_name = backend.new_repo_name()
         description = '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=backend.alias,
                 repo_description=description,
                 clone_uri='http://repo.invalid/repo',
                 csrf_token=csrf_token))
         response.mustcontain('invalid clone url')
 
     @pytest.mark.xfail_backends("svn", reason="Depends on import support")
     def test_create_remote_repo_wrong_clone_uri_hg_svn(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name()
         description = '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=backend.alias,
                 repo_description=description,
                 clone_uri='svn+http://svn.invalid/repo',
                 csrf_token=csrf_token))
         response.mustcontain('invalid clone url')
 
     @pytest.mark.parametrize("suffix", [u'', u'ąęł'], ids=['', 'non-ascii'])
     def test_delete(self, autologin_user, backend, suffix, csrf_token):
         repo = backend.create_repo(name_suffix=suffix)
         repo_name = repo.repo_name
 
         response = self.app.post(url('repo', repo_name=repo_name),
                                  params={'_method': 'delete',
                                          'csrf_token': csrf_token})
         assert_session_flash(response, 'Deleted repository %s' % (repo_name))
         response.follow()
 
         # check if repo was deleted from db
         assert RepoModel().get_by_repo_name(repo_name) is None
         assert not repo_on_filesystem(repo_name)
 
     def test_show(self, autologin_user, backend):
         self.app.get(url('repo', repo_name=backend.repo_name))
 
     def test_edit(self, backend, autologin_user):
         self.app.get(url('edit_repo', repo_name=backend.repo_name))
 
     def test_edit_accessible_when_missing_requirements(
             self, backend_hg, autologin_user):
         scm_patcher = mock.patch.object(
             Repository, 'scm_instance', side_effect=RepositoryRequirementError)
         with scm_patcher:
             self.app.get(url('edit_repo', repo_name=backend_hg.repo_name))
 
     def test_set_private_flag_sets_default_to_none(
             self, autologin_user, backend, csrf_token):
         # initially repository perm should be read
         perm = _get_permission_for_user(user='default', repo=backend.repo_name)
         assert len(perm) == 1
         assert perm[0].permission.permission_name == 'repository.read'
         assert not backend.repo.private
 
         response = self.app.post(
             url('repo', repo_name=backend.repo_name),
             fixture._get_repo_create_params(
                 repo_private=1,
                 repo_name=backend.repo_name,
                 repo_type=backend.alias,
                 user=TEST_USER_ADMIN_LOGIN,
                 _method='put',
                 csrf_token=csrf_token))
         assert_session_flash(
             response,
             msg='Repository %s updated successfully' % (backend.repo_name))
         assert backend.repo.private
 
         # now the repo default permission should be None
         perm = _get_permission_for_user(user='default', repo=backend.repo_name)
         assert len(perm) == 1
         assert perm[0].permission.permission_name == 'repository.none'
 
         response = self.app.post(
             url('repo', repo_name=backend.repo_name),
             fixture._get_repo_create_params(
                 repo_private=False,
                 repo_name=backend.repo_name,
                 repo_type=backend.alias,
                 user=TEST_USER_ADMIN_LOGIN,
                 _method='put',
                 csrf_token=csrf_token))
         assert_session_flash(
             response,
             msg='Repository %s updated successfully' % (backend.repo_name))
         assert not backend.repo.private
 
         # we turn off private now the repo default permission should stay None
         perm = _get_permission_for_user(user='default', repo=backend.repo_name)
         assert len(perm) == 1
         assert perm[0].permission.permission_name == 'repository.none'
 
         # update this permission back
         perm[0].permission = Permission.get_by_key('repository.read')
         Session().add(perm[0])
         Session().commit()
 
     def test_default_user_cannot_access_private_repo_in_a_group(
             self, autologin_user, user_util, backend, csrf_token):
 
         group = user_util.create_repo_group()
 
         repo = backend.create_repo(
             repo_private=True, repo_group=group, repo_copy_permissions=True)
 
         permissions = _get_permission_for_user(
             user='default', repo=repo.repo_name)
         assert len(permissions) == 1
         assert permissions[0].permission.permission_name == 'repository.none'
         assert permissions[0].repository.private is True
 
     def test_set_repo_fork_has_no_self_id(self, autologin_user, backend):
         repo = backend.repo
         response = self.app.get(
             url('edit_repo_advanced', repo_name=backend.repo_name))
         opt = """<option value="%s">vcs_test_git</option>""" % repo.repo_id
         response.mustcontain(no=[opt])
 
     def test_set_fork_of_target_repo(
             self, autologin_user, backend, csrf_token):
         target_repo = 'target_%s' % backend.alias
         fixture.create_repo(target_repo, repo_type=backend.alias)
         repo2 = Repository.get_by_repo_name(target_repo)
         response = self.app.post(
             url('edit_repo_advanced_fork', repo_name=backend.repo_name),
             params={'id_fork_of': repo2.repo_id, '_method': 'put',
                     'csrf_token': csrf_token})
         repo = Repository.get_by_repo_name(backend.repo_name)
         repo2 = Repository.get_by_repo_name(target_repo)
         assert_session_flash(
             response,
             'Marked repo %s as fork of %s' % (repo.repo_name, repo2.repo_name))
 
         assert repo.fork == repo2
         response = response.follow()
         # check if given repo is selected
 
         opt = 'This repository is a fork of <a href="%s">%s</a>' % (
             url('summary_home', repo_name=repo2.repo_name), repo2.repo_name)
 
         response.mustcontain(opt)
 
         fixture.destroy_repo(target_repo, forks='detach')
 
     @pytest.mark.backends("hg", "git")
     def test_set_fork_of_other_type_repo(self, autologin_user, backend,
                                          csrf_token):
         TARGET_REPO_MAP = {
             'git': {
                 'type': 'hg',
                 'repo_name': HG_REPO},
             'hg': {
                 'type': 'git',
                 'repo_name': GIT_REPO},
         }
         target_repo = TARGET_REPO_MAP[backend.alias]
 
         repo2 = Repository.get_by_repo_name(target_repo['repo_name'])
         response = self.app.post(
             url('edit_repo_advanced_fork', repo_name=backend.repo_name),
             params={'id_fork_of': repo2.repo_id, '_method': 'put',
                     'csrf_token': csrf_token})
         assert_session_flash(
             response,
             'Cannot set repository as fork of repository with other type')
 
     def test_set_fork_of_none(self, autologin_user, backend, csrf_token):
         # mark it as None
         response = self.app.post(
             url('edit_repo_advanced_fork', repo_name=backend.repo_name),
             params={'id_fork_of': None, '_method': 'put',
                     'csrf_token': csrf_token})
         assert_session_flash(
             response,
             'Marked repo %s as fork of %s'
             % (backend.repo_name, "Nothing"))
         assert backend.repo.fork is None
 
     def test_set_fork_of_same_repo(self, autologin_user, backend, csrf_token):
         repo = Repository.get_by_repo_name(backend.repo_name)
         response = self.app.post(
             url('edit_repo_advanced_fork', repo_name=backend.repo_name),
             params={'id_fork_of': repo.repo_id, '_method': 'put',
                     'csrf_token': csrf_token})
         assert_session_flash(
             response, 'An error occurred during this operation')
 
     def test_create_on_top_level_without_permissions(self, backend):
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         csrf_token = auth.get_csrf_token(session)
 
         # revoke
         user_model = UserModel()
         # disable fork and create on default user
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.create.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.create.none')
         user_model.revoke_perm(User.DEFAULT_USER, 'hg.fork.repository')
         user_model.grant_perm(User.DEFAULT_USER, 'hg.fork.none')
 
         # disable on regular user
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.create.none')
         user_model.revoke_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.repository')
         user_model.grant_perm(TEST_USER_REGULAR_LOGIN, 'hg.fork.none')
         Session().commit()
 
         repo_name = backend.new_repo_name()
         description = '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=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         response.mustcontain(
             u"You do not have the permission to store repositories in "
             u"the root location.")
 
     @mock.patch.object(RepoModel, '_create_filesystem_repo', error_function)
     def test_create_repo_when_filesystem_op_fails(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.new_repo_name()
         description = '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=backend.alias,
                 repo_description=description,
                 csrf_token=csrf_token))
 
         assert_session_flash(
             response, 'Error creating repository %s' % repo_name)
         # repo must not be in db
         assert backend.repo is None
         # repo must not be in filesystem !
         assert not repo_on_filesystem(repo_name)
 
     def assert_repository_is_created_correctly(
             self, repo_name, description, backend):
         repo_name_utf8 = repo_name.encode('utf-8')
 
         # 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}
         assert_session_flash(
             response,
             u'Created repository <a href="/%s">%s</a>'
             % (urllib.quote(repo_name_utf8), repo_name))
 
         # test if the repo was created in the database
         new_repo = RepoModel().get_by_repo_name(repo_name)
 
         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(backend.alias)
 
         assert repo_on_filesystem(repo_name)
 
 
 @pytest.mark.usefixtures("app")
 class TestVcsSettings(object):
     FORM_DATA = {
         'inherit_global_settings': False,
         'hooks_changegroup_repo_size': False,
         'hooks_changegroup_push_logger': False,
         'hooks_outgoing_pull_logger': False,
         'extensions_largefiles': False,
-        'phases_publish': 'false',
+        'phases_publish': 'False',
         'rhodecode_pr_merge_enabled': False,
         'rhodecode_use_outdated_comments': False,
         'new_svn_branch': '',
         'new_svn_tag': ''
     }
 
     @pytest.mark.skip_backends('svn')
     def test_global_settings_initial_values(self, autologin_user, backend):
         repo_name = backend.repo_name
         response = self.app.get(url('repo_vcs_settings', repo_name=repo_name))
 
         expected_settings = (
             'rhodecode_use_outdated_comments', 'rhodecode_pr_merge_enabled',
             'hooks_changegroup_repo_size', 'hooks_changegroup_push_logger',
             'hooks_outgoing_pull_logger'
         )
         for setting in expected_settings:
             self.assert_repo_value_equals_global_value(response, setting)
 
     def test_show_settings_requires_repo_admin_permission(
             self, backend, user_util, settings_util):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
         user_util.grant_user_permission_to_repo(repo, user, 'repository.admin')
         login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         self.app.get(url('repo_vcs_settings', repo_name=repo_name), status=200)
 
     def test_inherit_global_settings_flag_is_true_by_default(
             self, autologin_user, backend):
         repo_name = backend.repo_name
         response = self.app.get(url('repo_vcs_settings', repo_name=repo_name))
 
         assert_response = AssertResponse(response)
         element = assert_response.get_element('#inherit_global_settings')
         assert element.checked
 
     @pytest.mark.parametrize('checked_value', [True, False])
     def test_inherit_global_settings_value(
             self, autologin_user, backend, checked_value, settings_util):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         settings_util.create_repo_rhodecode_setting(
             repo, 'inherit_vcs_settings', checked_value, 'bool')
         response = self.app.get(url('repo_vcs_settings', repo_name=repo_name))
 
         assert_response = AssertResponse(response)
         element = assert_response.get_element('#inherit_global_settings')
         assert element.checked == checked_value
 
     @pytest.mark.skip_backends('svn')
     def test_hooks_settings_are_created(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             for section, key in VcsSettingsModel.HOOKS_SETTINGS:
                 ui = settings.get_ui_by_section_and_key(section, key)
                 assert ui.ui_active is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_hooks_settings_are_not_created_for_svn(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             for section, key in VcsSettingsModel.HOOKS_SETTINGS:
                 ui = settings.get_ui_by_section_and_key(section, key)
                 assert ui is None
         finally:
             self._cleanup_repo_settings(settings)
 
     @pytest.mark.skip_backends('svn')
     def test_hooks_settings_are_updated(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         settings = SettingsModel(repo=repo_name)
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings.create_ui_section_value(section, '', key=key, active=True)
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             for section, key in VcsSettingsModel.HOOKS_SETTINGS:
                 ui = settings.get_ui_by_section_and_key(section, key)
                 assert ui.ui_active is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_hooks_settings_are_not_updated_for_svn(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         settings = SettingsModel(repo=repo_name)
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings.create_ui_section_value(section, '', key=key, active=True)
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             for section, key in VcsSettingsModel.HOOKS_SETTINGS:
                 ui = settings.get_ui_by_section_and_key(section, key)
                 assert ui.ui_active is True
         finally:
             self._cleanup_repo_settings(settings)
 
     @pytest.mark.skip_backends('svn')
     def test_pr_settings_are_created(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             for name in VcsSettingsModel.GENERAL_SETTINGS:
                 setting = settings.get_setting_by_name(name)
                 assert setting.app_settings_value is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_pr_settings_are_not_created_for_svn(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             for name in VcsSettingsModel.GENERAL_SETTINGS:
                 setting = settings.get_setting_by_name(name)
                 assert setting is None
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_pr_settings_creation_requires_repo_admin_permission(
             self, backend, user_util, settings_util, csrf_token):
         repo = backend.create_repo()
         repo_name = repo.repo_name
         user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
 
         logout_user_session(self.app, csrf_token)
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         new_csrf_token = auth.get_csrf_token(session)
 
         user_util.grant_user_permission_to_repo(repo, user, 'repository.admin')
         data = self.FORM_DATA.copy()
         data['csrf_token'] = new_csrf_token
         settings = SettingsModel(repo=repo_name)
 
         try:
             self.app.post(
                 url('repo_vcs_settings', repo_name=repo_name), data,
                 status=302)
         finally:
             self._cleanup_repo_settings(settings)
 
     @pytest.mark.skip_backends('svn')
     def test_pr_settings_are_updated(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         settings = SettingsModel(repo=repo_name)
         for name in VcsSettingsModel.GENERAL_SETTINGS:
             settings.create_or_update_setting(name, True, 'bool')
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             for name in VcsSettingsModel.GENERAL_SETTINGS:
                 setting = settings.get_setting_by_name(name)
                 assert setting.app_settings_value is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_pr_settings_are_not_updated_for_svn(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         settings = SettingsModel(repo=repo_name)
         for name in VcsSettingsModel.GENERAL_SETTINGS:
             settings.create_or_update_setting(name, True, 'bool')
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             for name in VcsSettingsModel.GENERAL_SETTINGS:
                 setting = settings.get_setting_by_name(name)
                 assert setting.app_settings_value is True
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_svn_settings_are_created(
             self, autologin_user, backend_svn, csrf_token, settings_util):
         repo_name = backend_svn.repo_name
         data = self.FORM_DATA.copy()
         data['new_svn_tag'] = 'svn-tag'
         data['new_svn_branch'] = 'svn-branch'
         data['csrf_token'] = csrf_token
 
         # Create few global settings to make sure that uniqueness validators
         # are not triggered
         settings_util.create_rhodecode_ui(
             VcsSettingsModel.SVN_BRANCH_SECTION, 'svn-branch')
         settings_util.create_rhodecode_ui(
             VcsSettingsModel.SVN_TAG_SECTION, 'svn-tag')
 
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             svn_branches = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_BRANCH_SECTION)
             svn_branch_names = [b.ui_value for b in svn_branches]
             svn_tags = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_TAG_SECTION)
             svn_tag_names = [b.ui_value for b in svn_tags]
             assert 'svn-branch' in svn_branch_names
             assert 'svn-tag' in svn_tag_names
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_svn_settings_are_unique(
             self, autologin_user, backend_svn, csrf_token, settings_util):
         repo = backend_svn.repo
         repo_name = repo.repo_name
         data = self.FORM_DATA.copy()
         data['new_svn_tag'] = 'test_tag'
         data['new_svn_branch'] = 'test_branch'
         data['csrf_token'] = csrf_token
         settings_util.create_repo_rhodecode_ui(
             repo, VcsSettingsModel.SVN_BRANCH_SECTION, 'test_branch')
         settings_util.create_repo_rhodecode_ui(
             repo, VcsSettingsModel.SVN_TAG_SECTION, 'test_tag')
 
         response = self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=200)
         response.mustcontain('Pattern already exists')
 
     def test_svn_settings_with_empty_values_are_not_created(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             svn_branches = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_BRANCH_SECTION)
             svn_tags = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_TAG_SECTION)
             assert len(svn_branches) == 0
             assert len(svn_tags) == 0
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_svn_settings_are_shown_for_svn_repository(
             self, autologin_user, backend_svn, csrf_token):
         repo_name = backend_svn.repo_name
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         response.mustcontain('Subversion Settings')
 
     @pytest.mark.skip_backends('svn')
     def test_svn_settings_are_not_created_for_not_svn_repository(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             svn_branches = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_BRANCH_SECTION)
             svn_tags = settings.get_ui_by_section(
                 VcsSettingsModel.SVN_TAG_SECTION)
             assert len(svn_branches) == 0
             assert len(svn_tags) == 0
         finally:
             self._cleanup_repo_settings(settings)
 
     @pytest.mark.skip_backends('svn')
     def test_svn_settings_are_shown_only_for_svn_repository(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         response.mustcontain(no='Subversion Settings')
 
     def test_hg_settings_are_created(
             self, autologin_user, backend_hg, csrf_token):
         repo_name = backend_hg.repo_name
         data = self.FORM_DATA.copy()
         data['new_svn_tag'] = 'svn-tag'
         data['new_svn_branch'] = 'svn-branch'
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             largefiles_ui = settings.get_ui_by_section_and_key(
                 'extensions', 'largefiles')
             assert largefiles_ui.ui_active is False
             phases_ui = settings.get_ui_by_section_and_key(
                 'phases', 'publish')
             assert str2bool(phases_ui.ui_value) is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_hg_settings_are_updated(
             self, autologin_user, backend_hg, csrf_token):
         repo_name = backend_hg.repo_name
         settings = SettingsModel(repo=repo_name)
         settings.create_ui_section_value(
             'extensions', '', key='largefiles', active=True)
         settings.create_ui_section_value(
             'phases', '1', key='publish', active=True)
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             largefiles_ui = settings.get_ui_by_section_and_key(
                 'extensions', 'largefiles')
             assert largefiles_ui.ui_active is False
             phases_ui = settings.get_ui_by_section_and_key(
                 'phases', 'publish')
             assert str2bool(phases_ui.ui_value) is False
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_hg_settings_are_shown_for_hg_repository(
             self, autologin_user, backend_hg, csrf_token):
         repo_name = backend_hg.repo_name
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         response.mustcontain('Mercurial Settings')
 
     @pytest.mark.skip_backends('hg')
     def test_hg_settings_are_created_only_for_hg_repository(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         settings = SettingsModel(repo=repo_name)
         try:
             largefiles_ui = settings.get_ui_by_section_and_key(
                 'extensions', 'largefiles')
             assert largefiles_ui is None
             phases_ui = settings.get_ui_by_section_and_key(
                 'phases', 'publish')
             assert phases_ui is None
         finally:
             self._cleanup_repo_settings(settings)
 
     @pytest.mark.skip_backends('hg')
     def test_hg_settings_are_shown_only_for_hg_repository(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         response.mustcontain(no='Mercurial Settings')
 
     @pytest.mark.skip_backends('hg')
     def test_hg_settings_are_updated_only_for_hg_repository(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         settings = SettingsModel(repo=repo_name)
         settings.create_ui_section_value(
             'extensions', '', key='largefiles', active=True)
         settings.create_ui_section_value(
             'phases', '1', key='publish', active=True)
 
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
         try:
             largefiles_ui = settings.get_ui_by_section_and_key(
                 'extensions', 'largefiles')
             assert largefiles_ui.ui_active is True
             phases_ui = settings.get_ui_by_section_and_key(
                 'phases', 'publish')
             assert phases_ui.ui_value == '1'
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_per_repo_svn_settings_are_displayed(
             self, autologin_user, backend_svn, settings_util):
         repo = backend_svn.create_repo()
         repo_name = repo.repo_name
         branches = [
             settings_util.create_repo_rhodecode_ui(
                 repo, VcsSettingsModel.SVN_BRANCH_SECTION,
                 'branch_{}'.format(i))
             for i in range(10)]
         tags = [
             settings_util.create_repo_rhodecode_ui(
                 repo, VcsSettingsModel.SVN_TAG_SECTION, 'tag_{}'.format(i))
             for i in range(10)]
 
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         assert_response = AssertResponse(response)
         for branch in branches:
             css_selector = '[name=branch_value_{}]'.format(branch.ui_id)
             element = assert_response.get_element(css_selector)
             assert element.value == branch.ui_value
         for tag in tags:
             css_selector = '[name=tag_ui_value_new_{}]'.format(tag.ui_id)
             element = assert_response.get_element(css_selector)
             assert element.value == tag.ui_value
 
     def test_per_repo_hg_and_pr_settings_are_not_displayed_for_svn(
             self, autologin_user, backend_svn, settings_util):
         repo = backend_svn.create_repo()
         repo_name = repo.repo_name
         response = self.app.get(
             url('repo_vcs_settings', repo_name=repo_name), status=200)
         response.mustcontain(no='<label>Hooks:</label>')
         response.mustcontain(no='<label>Pull Request Settings:</label>')
 
     def test_inherit_global_settings_value_is_saved(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         data['inherit_global_settings'] = True
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
 
         settings = SettingsModel(repo=repo_name)
         vcs_settings = VcsSettingsModel(repo=repo_name)
         try:
             assert vcs_settings.inherit_global_settings is True
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_repo_cache_is_invalidated_when_settings_are_updated(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         data['inherit_global_settings'] = True
         settings = SettingsModel(repo=repo_name)
 
         invalidation_patcher = mock.patch(
             'rhodecode.controllers.admin.repos.ScmModel.mark_for_invalidation')
         with invalidation_patcher as invalidation_mock:
             self.app.post(
                 url('repo_vcs_settings', repo_name=repo_name), data,
                 status=302)
         try:
             invalidation_mock.assert_called_once_with(repo_name, delete=True)
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_other_settings_not_saved_inherit_global_settings_is_true(
             self, autologin_user, backend, csrf_token):
         repo_name = backend.repo_name
         data = self.FORM_DATA.copy()
         data['csrf_token'] = csrf_token
         data['inherit_global_settings'] = True
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data, status=302)
 
         settings = SettingsModel(repo=repo_name)
         ui_settings = (
             VcsSettingsModel.HOOKS_SETTINGS + VcsSettingsModel.HG_SETTINGS)
 
         vcs_settings = []
         try:
             for section, key in ui_settings:
                 ui = settings.get_ui_by_section_and_key(section, key)
                 if ui:
                     vcs_settings.append(ui)
             vcs_settings.extend(settings.get_ui_by_section(
                 VcsSettingsModel.SVN_BRANCH_SECTION))
             vcs_settings.extend(settings.get_ui_by_section(
                 VcsSettingsModel.SVN_TAG_SECTION))
             for name in VcsSettingsModel.GENERAL_SETTINGS:
                 setting = settings.get_setting_by_name(name)
                 if setting:
                     vcs_settings.append(setting)
             assert vcs_settings == []
         finally:
             self._cleanup_repo_settings(settings)
 
     def test_delete_svn_branch_and_tag_patterns(
             self, autologin_user, backend_svn, settings_util, csrf_token):
         repo = backend_svn.create_repo()
         repo_name = repo.repo_name
         branch = settings_util.create_repo_rhodecode_ui(
             repo, VcsSettingsModel.SVN_BRANCH_SECTION, 'test_branch',
             cleanup=False)
         tag = settings_util.create_repo_rhodecode_ui(
             repo, VcsSettingsModel.SVN_TAG_SECTION, 'test_tag', cleanup=False)
         data = {
             '_method': 'delete',
             'csrf_token': csrf_token
         }
         for id_ in (branch.ui_id, tag.ui_id):
             data['delete_svn_pattern'] = id_,
             self.app.post(
                 url('repo_vcs_settings', repo_name=repo_name), data,
                 headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=200)
         settings = VcsSettingsModel(repo=repo_name)
         assert settings.get_repo_svn_branch_patterns() == []
 
     def test_delete_svn_branch_requires_repo_admin_permission(
             self, backend_svn, user_util, settings_util, csrf_token):
         repo = backend_svn.create_repo()
         repo_name = repo.repo_name
         user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
         logout_user_session(self.app, csrf_token)
         session = login_user_session(
             self.app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
         csrf_token = auth.get_csrf_token(session)
         user_util.grant_user_permission_to_repo(repo, user, 'repository.admin')
         branch = settings_util.create_repo_rhodecode_ui(
             repo, VcsSettingsModel.SVN_BRANCH_SECTION, 'test_branch',
             cleanup=False)
         data = {
             '_method': 'delete',
             'csrf_token': csrf_token,
             'delete_svn_pattern': branch.ui_id
         }
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data,
             headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=200)
 
     def test_delete_svn_branch_raises_400_when_not_found(
             self, autologin_user, backend_svn, settings_util, csrf_token):
         repo_name = backend_svn.repo_name
         data = {
             '_method': 'delete',
             'delete_svn_pattern': 123,
             'csrf_token': csrf_token
         }
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data,
             headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=400)
 
     def test_delete_svn_branch_raises_400_when_no_id_specified(
             self, autologin_user, backend_svn, settings_util, csrf_token):
         repo_name = backend_svn.repo_name
         data = {
             '_method': 'delete',
             'csrf_token': csrf_token
         }
         self.app.post(
             url('repo_vcs_settings', repo_name=repo_name), data,
             headers={'X-REQUESTED-WITH': 'XMLHttpRequest', }, status=400)
 
     def _cleanup_repo_settings(self, settings_model):
         cleanup = []
         ui_settings = (
             VcsSettingsModel.HOOKS_SETTINGS + VcsSettingsModel.HG_SETTINGS)
 
         for section, key in ui_settings:
             ui = settings_model.get_ui_by_section_and_key(section, key)
             if ui:
                 cleanup.append(ui)
 
         cleanup.extend(settings_model.get_ui_by_section(
             VcsSettingsModel.INHERIT_SETTINGS))
         cleanup.extend(settings_model.get_ui_by_section(
             VcsSettingsModel.SVN_BRANCH_SECTION))
         cleanup.extend(settings_model.get_ui_by_section(
             VcsSettingsModel.SVN_TAG_SECTION))
 
         for name in VcsSettingsModel.GENERAL_SETTINGS:
             setting = settings_model.get_setting_by_name(name)
             if setting:
                 cleanup.append(setting)
 
         for object_ in cleanup:
             Session().delete(object_)
         Session().commit()
 
     def assert_repo_value_equals_global_value(self, response, setting):
         assert_response = AssertResponse(response)
         global_css_selector = '[name={}_inherited]'.format(setting)
         repo_css_selector = '[name={}]'.format(setting)
         repo_element = assert_response.get_element(repo_css_selector)
         global_element = assert_response.get_element(global_css_selector)
         assert repo_element.value == global_element.value
 
 
 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

rhodecode/tests/models/settings/test_vcs_settings.py

@@ -1,1034 +1,1034 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import mock
 import pytest
 
 from rhodecode.lib.utils2 import str2bool
 from rhodecode.model.meta import Session
 from rhodecode.model.settings import VcsSettingsModel, UiSetting
 
 
 HOOKS_FORM_DATA = {
     'hooks_changegroup_repo_size': True,
     'hooks_changegroup_push_logger': True,
     'hooks_outgoing_pull_logger': True
 }
 
 SVN_FORM_DATA = {
     'new_svn_branch': 'test-branch',
     'new_svn_tag': 'test-tag'
 }
 
 GENERAL_FORM_DATA = {
     'rhodecode_pr_merge_enabled': True,
     'rhodecode_use_outdated_comments': True,
     'rhodecode_hg_use_rebase_for_merging': True,
 }
 
 
 class TestInheritGlobalSettingsProperty(object):
     def test_get_raises_exception_when_repository_not_specified(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.inherit_global_settings
         assert exc_info.value.message == 'Repository is not specified'
 
     def test_true_is_returned_when_value_is_not_found(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         assert model.inherit_global_settings is True
 
     def test_value_is_returned(self, repo_stub, settings_util):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         settings_util.create_repo_rhodecode_setting(
             repo_stub, VcsSettingsModel.INHERIT_SETTINGS, False, 'bool')
         assert model.inherit_global_settings is False
 
     def test_value_is_set(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model.inherit_global_settings = False
         setting = model.repo_settings.get_setting_by_name(
             VcsSettingsModel.INHERIT_SETTINGS)
         try:
             assert setting.app_settings_type == 'bool'
             assert setting.app_settings_value is False
         finally:
             Session().delete(setting)
             Session().commit()
 
     def test_set_raises_exception_when_repository_not_specified(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.inherit_global_settings = False
         assert exc_info.value.message == 'Repository is not specified'
 
 
 class TestVcsSettingsModel(object):
     def test_global_svn_branch_patterns(self):
         model = VcsSettingsModel()
         expected_result = {'test': 'test'}
         with mock.patch.object(model, 'global_settings') as settings_mock:
             get_settings = settings_mock.get_ui_by_section
             get_settings.return_value = expected_result
             settings_mock.return_value = expected_result
             result = model.get_global_svn_branch_patterns()
 
         get_settings.assert_called_once_with(model.SVN_BRANCH_SECTION)
         assert expected_result == result
 
     def test_repo_svn_branch_patterns(self):
         model = VcsSettingsModel()
         expected_result = {'test': 'test'}
         with mock.patch.object(model, 'repo_settings') as settings_mock:
             get_settings = settings_mock.get_ui_by_section
             get_settings.return_value = expected_result
             settings_mock.return_value = expected_result
             result = model.get_repo_svn_branch_patterns()
 
         get_settings.assert_called_once_with(model.SVN_BRANCH_SECTION)
         assert expected_result == result
 
     def test_repo_svn_branch_patterns_raises_exception_when_repo_is_not_set(
             self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.get_repo_svn_branch_patterns()
         assert exc_info.value.message == 'Repository is not specified'
 
     def test_global_svn_tag_patterns(self):
         model = VcsSettingsModel()
         expected_result = {'test': 'test'}
         with mock.patch.object(model, 'global_settings') as settings_mock:
             get_settings = settings_mock.get_ui_by_section
             get_settings.return_value = expected_result
             settings_mock.return_value = expected_result
             result = model.get_global_svn_tag_patterns()
 
         get_settings.assert_called_once_with(model.SVN_TAG_SECTION)
         assert expected_result == result
 
     def test_repo_svn_tag_patterns(self):
         model = VcsSettingsModel()
         expected_result = {'test': 'test'}
         with mock.patch.object(model, 'repo_settings') as settings_mock:
             get_settings = settings_mock.get_ui_by_section
             get_settings.return_value = expected_result
             settings_mock.return_value = expected_result
             result = model.get_repo_svn_tag_patterns()
 
         get_settings.assert_called_once_with(model.SVN_TAG_SECTION)
         assert expected_result == result
 
     def test_repo_svn_tag_patterns_raises_exception_when_repo_is_not_set(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.get_repo_svn_tag_patterns()
         assert exc_info.value.message == 'Repository is not specified'
 
     def test_get_global_settings(self):
         expected_result = {'test': 'test'}
         model = VcsSettingsModel()
         with mock.patch.object(model, '_collect_all_settings') as collect_mock:
             collect_mock.return_value = expected_result
             result = model.get_global_settings()
 
         collect_mock.assert_called_once_with(global_=True)
         assert result == expected_result
 
     def test_get_repo_settings(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         expected_result = {'test': 'test'}
         with mock.patch.object(model, '_collect_all_settings') as collect_mock:
             collect_mock.return_value = expected_result
             result = model.get_repo_settings()
 
         collect_mock.assert_called_once_with(global_=False)
         assert result == expected_result
 
     @pytest.mark.parametrize('settings, global_', [
         ('global_settings', True),
         ('repo_settings', False)
     ])
     def test_collect_all_settings(self, settings, global_):
         model = VcsSettingsModel()
         result_mock = self._mock_result()
 
         settings_patch = mock.patch.object(model, settings)
         with settings_patch as settings_mock:
             settings_mock.get_ui_by_section_and_key.return_value = result_mock
             settings_mock.get_setting_by_name.return_value = result_mock
             result = model._collect_all_settings(global_=global_)
 
         ui_settings = model.HG_SETTINGS + model.HOOKS_SETTINGS
         self._assert_get_settings_calls(
             settings_mock, ui_settings, model.GENERAL_SETTINGS)
         self._assert_collect_all_settings_result(
             ui_settings, model.GENERAL_SETTINGS, result)
 
     @pytest.mark.parametrize('settings, global_', [
         ('global_settings', True),
         ('repo_settings', False)
     ])
     def test_collect_all_settings_without_empty_value(self, settings, global_):
         model = VcsSettingsModel()
 
         settings_patch = mock.patch.object(model, settings)
         with settings_patch as settings_mock:
             settings_mock.get_ui_by_section_and_key.return_value = None
             settings_mock.get_setting_by_name.return_value = None
             result = model._collect_all_settings(global_=global_)
 
         assert result == {}
 
     def _mock_result(self):
         result_mock = mock.Mock()
         result_mock.ui_value = 'ui_value'
         result_mock.ui_active = True
         result_mock.app_settings_value = 'setting_value'
         return result_mock
 
     def _assert_get_settings_calls(
             self, settings_mock, ui_settings, general_settings):
         assert (
             settings_mock.get_ui_by_section_and_key.call_count ==
             len(ui_settings))
         assert (
             settings_mock.get_setting_by_name.call_count ==
             len(general_settings))
 
         for section, key in ui_settings:
             expected_call = mock.call(section, key)
             assert (
                 expected_call in
                 settings_mock.get_ui_by_section_and_key.call_args_list)
 
         for name in general_settings:
             expected_call = mock.call(name)
             assert (
                 expected_call in
                 settings_mock.get_setting_by_name.call_args_list)
 
     def _assert_collect_all_settings_result(
             self, ui_settings, general_settings, result):
         expected_result = {}
         for section, key in ui_settings:
             key = '{}_{}'.format(section, key.replace('.', '_'))
             value = True if section in ('extensions', 'hooks') else 'ui_value'
             expected_result[key] = value
 
         for name in general_settings:
             key = 'rhodecode_' + name
             expected_result[key] = 'setting_value'
 
         assert expected_result == result
 
 
 class TestCreateOrUpdateRepoHookSettings(object):
     def test_create_when_no_repo_object_found(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
 
         self._create_settings(model, HOOKS_FORM_DATA)
 
         cleanup = []
         try:
             for section, key in model.HOOKS_SETTINGS:
                 ui = model.repo_settings.get_ui_by_section_and_key(
                     section, key)
                 assert ui.ui_active is True
                 cleanup.append(ui)
         finally:
             for ui in cleanup:
                 Session().delete(ui)
             Session().commit()
 
     def test_create_raises_exception_when_data_incomplete(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
 
         deleted_key = 'hooks_changegroup_repo_size'
         data = HOOKS_FORM_DATA.copy()
         data.pop(deleted_key)
 
         with pytest.raises(ValueError) as exc_info:
             model.create_or_update_repo_hook_settings(data)
         assert (
             exc_info.value.message ==
             'The given data does not contain {} key'.format(deleted_key))
 
     def test_update_when_repo_object_found(self, repo_stub, settings_util):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         for section, key in model.HOOKS_SETTINGS:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, None, key=key, active=False)
         model.create_or_update_repo_hook_settings(HOOKS_FORM_DATA)
         for section, key in model.HOOKS_SETTINGS:
             ui = model.repo_settings.get_ui_by_section_and_key(section, key)
             assert ui.ui_active is True
 
     def _create_settings(self, model, data):
         global_patch = mock.patch.object(model, 'global_settings')
         global_setting = mock.Mock()
         global_setting.ui_value = 'Test value'
         with global_patch as global_mock:
             global_mock.get_ui_by_section_and_key.return_value = global_setting
             model.create_or_update_repo_hook_settings(HOOKS_FORM_DATA)
 
 
 class TestUpdateGlobalHookSettings(object):
     def test_update_raises_exception_when_data_incomplete(self):
         model = VcsSettingsModel()
 
         deleted_key = 'hooks_changegroup_repo_size'
         data = HOOKS_FORM_DATA.copy()
         data.pop(deleted_key)
 
         with pytest.raises(ValueError) as exc_info:
             model.update_global_hook_settings(data)
         assert (
             exc_info.value.message ==
             'The given data does not contain {} key'.format(deleted_key))
 
     def test_update_global_hook_settings(self, settings_util):
         model = VcsSettingsModel()
         setting_mock = mock.MagicMock()
         setting_mock.ui_active = False
         get_settings_patcher = mock.patch.object(
             model.global_settings, 'get_ui_by_section_and_key',
             return_value=setting_mock)
         session_patcher = mock.patch('rhodecode.model.settings.Session')
         with get_settings_patcher as get_settings_mock, session_patcher:
             model.update_global_hook_settings(HOOKS_FORM_DATA)
         assert setting_mock.ui_active is True
         assert get_settings_mock.call_count == 3
 
 
 class TestCreateOrUpdateRepoGeneralSettings(object):
     def test_calls_create_or_update_general_settings(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         create_patch = mock.patch.object(
             model, '_create_or_update_general_settings')
         with create_patch as create_mock:
             model.create_or_update_repo_pr_settings(GENERAL_FORM_DATA)
         create_mock.assert_called_once_with(
             model.repo_settings, GENERAL_FORM_DATA)
 
     def test_raises_exception_when_repository_is_not_specified(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.create_or_update_repo_pr_settings(GENERAL_FORM_DATA)
         assert exc_info.value.message == 'Repository is not specified'
 
 
 class TestCreateOrUpdatGlobalGeneralSettings(object):
     def test_calls_create_or_update_general_settings(self):
         model = VcsSettingsModel()
         create_patch = mock.patch.object(
             model, '_create_or_update_general_settings')
         with create_patch as create_mock:
             model.create_or_update_global_pr_settings(GENERAL_FORM_DATA)
         create_mock.assert_called_once_with(
             model.global_settings, GENERAL_FORM_DATA)
 
 
 class TestCreateOrUpdateGeneralSettings(object):
     def test_create_when_no_repo_settings_found(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model._create_or_update_general_settings(
             model.repo_settings, GENERAL_FORM_DATA)
 
         cleanup = []
         try:
             for name in model.GENERAL_SETTINGS:
                 setting = model.repo_settings.get_setting_by_name(name)
                 assert setting.app_settings_value is True
                 cleanup.append(setting)
         finally:
             for setting in cleanup:
                 Session().delete(setting)
             Session().commit()
 
     def test_create_raises_exception_when_data_incomplete(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
 
         deleted_key = 'rhodecode_pr_merge_enabled'
         data = GENERAL_FORM_DATA.copy()
         data.pop(deleted_key)
 
         with pytest.raises(ValueError) as exc_info:
             model._create_or_update_general_settings(model.repo_settings, data)
         assert (
             exc_info.value.message ==
             'The given data does not contain {} key'.format(deleted_key))
 
     def test_update_when_repo_setting_found(self, repo_stub, settings_util):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         for name in model.GENERAL_SETTINGS:
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, name, False, 'bool')
 
         model._create_or_update_general_settings(
             model.repo_settings, GENERAL_FORM_DATA)
 
         for name in model.GENERAL_SETTINGS:
             setting = model.repo_settings.get_setting_by_name(name)
             assert setting.app_settings_value is True
 
 
 class TestCreateRepoSvnSettings(object):
     def test_calls_create_svn_settings(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         with mock.patch.object(model, '_create_svn_settings') as create_mock:
             model.create_repo_svn_settings(SVN_FORM_DATA)
         create_mock.assert_called_once_with(model.repo_settings, SVN_FORM_DATA)
 
     def test_raises_exception_when_repository_is_not_specified(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.create_repo_svn_settings(SVN_FORM_DATA)
         assert exc_info.value.message == 'Repository is not specified'
 
 
 class TestCreateSvnSettings(object):
     def test_create(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model._create_svn_settings(model.repo_settings, SVN_FORM_DATA)
         Session().commit()
 
         branch_ui = model.repo_settings.get_ui_by_section(
             model.SVN_BRANCH_SECTION)
         tag_ui = model.repo_settings.get_ui_by_section(
             model.SVN_TAG_SECTION)
 
         try:
             assert len(branch_ui) == 1
             assert len(tag_ui) == 1
         finally:
             Session().delete(branch_ui[0])
             Session().delete(tag_ui[0])
             Session().commit()
 
     def test_create_tag(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         data = SVN_FORM_DATA.copy()
         data.pop('new_svn_branch')
         model._create_svn_settings(model.repo_settings, data)
         Session().commit()
 
         branch_ui = model.repo_settings.get_ui_by_section(
             model.SVN_BRANCH_SECTION)
         tag_ui = model.repo_settings.get_ui_by_section(
             model.SVN_TAG_SECTION)
 
         try:
             assert len(branch_ui) == 0
             assert len(tag_ui) == 1
         finally:
             Session().delete(tag_ui[0])
             Session().commit()
 
     def test_create_nothing_when_no_svn_settings_specified(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model._create_svn_settings(model.repo_settings, {})
         Session().commit()
 
         branch_ui = model.repo_settings.get_ui_by_section(
             model.SVN_BRANCH_SECTION)
         tag_ui = model.repo_settings.get_ui_by_section(
             model.SVN_TAG_SECTION)
 
         assert len(branch_ui) == 0
         assert len(tag_ui) == 0
 
     def test_create_nothing_when_empty_settings_specified(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         data = {
             'new_svn_branch': '',
             'new_svn_tag': ''
         }
         model._create_svn_settings(model.repo_settings, data)
         Session().commit()
 
         branch_ui = model.repo_settings.get_ui_by_section(
             model.SVN_BRANCH_SECTION)
         tag_ui = model.repo_settings.get_ui_by_section(
             model.SVN_TAG_SECTION)
 
         assert len(branch_ui) == 0
         assert len(tag_ui) == 0
 
 
 class TestCreateOrUpdateUi(object):
     def test_create(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model._create_or_update_ui(
             model.repo_settings, 'test-section', 'test-key', active=False,
             value='False')
         Session().commit()
 
         created_ui = model.repo_settings.get_ui_by_section_and_key(
             'test-section', 'test-key')
 
         try:
             assert created_ui.ui_active is False
             assert str2bool(created_ui.ui_value) is False
         finally:
             Session().delete(created_ui)
             Session().commit()
 
     def test_update(self, repo_stub, settings_util):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
 
         largefiles, phases = model.HG_SETTINGS
         section = 'test-section'
         key = 'test-key'
         settings_util.create_repo_rhodecode_ui(
             repo_stub, section, 'True', key=key, active=True)
 
         model._create_or_update_ui(
             model.repo_settings, section, key, active=False, value='False')
         Session().commit()
 
         created_ui = model.repo_settings.get_ui_by_section_and_key(
             section, key)
         assert created_ui.ui_active is False
         assert str2bool(created_ui.ui_value) is False
 
 
 class TestCreateOrUpdateRepoHgSettings(object):
     FORM_DATA = {
         'extensions_largefiles': False,
         'phases_publish': False
     }
 
     def test_creates_repo_hg_settings_when_data_is_correct(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         with mock.patch.object(model, '_create_or_update_ui') as create_mock:
             model.create_or_update_repo_hg_settings(self.FORM_DATA)
         expected_calls = [
             mock.call(model.repo_settings, 'extensions', 'largefiles',
                       active=False, value=''),
             mock.call(model.repo_settings, 'phases', 'publish', value='False'),
         ]
         assert expected_calls == create_mock.call_args_list
 
     @pytest.mark.parametrize('field_to_remove', FORM_DATA.keys())
     def test_key_is_not_found(self, repo_stub, field_to_remove):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         data = self.FORM_DATA.copy()
         data.pop(field_to_remove)
         with pytest.raises(ValueError) as exc_info:
             model.create_or_update_repo_hg_settings(data)
         expected_message = 'The given data does not contain {} key'.format(
             field_to_remove)
         assert exc_info.value.message == expected_message
 
     def test_create_raises_exception_when_repository_not_specified(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.create_or_update_repo_hg_settings(self.FORM_DATA)
         assert exc_info.value.message == 'Repository is not specified'
 
 
 class TestUpdateGlobalSslSetting(object):
     def test_updates_global_hg_settings(self):
         model = VcsSettingsModel()
         with mock.patch.object(model, '_create_or_update_ui') as create_mock:
             model.update_global_ssl_setting('False')
         create_mock.assert_called_once_with(
             model.global_settings, 'web', 'push_ssl', value='False')
 
 
 class TestUpdateGlobalPathSetting(object):
     def test_updates_global_path_settings(self):
         model = VcsSettingsModel()
         with mock.patch.object(model, '_create_or_update_ui') as create_mock:
             model.update_global_path_setting('False')
         create_mock.assert_called_once_with(
             model.global_settings, 'paths', '/', value='False')
 
 
 class TestCreateOrUpdateGlobalHgSettings(object):
     FORM_DATA = {
         'extensions_largefiles': False,
         'largefiles_usercache': '/example/largefiles-store',
         'phases_publish': False,
         'extensions_hgsubversion': False
     }
 
     def test_creates_repo_hg_settings_when_data_is_correct(self):
         model = VcsSettingsModel()
         with mock.patch.object(model, '_create_or_update_ui') as create_mock:
             model.create_or_update_global_hg_settings(self.FORM_DATA)
         expected_calls = [
             mock.call(model.global_settings, 'extensions', 'largefiles',
                       active=False, value=''),
             mock.call(model.global_settings, 'largefiles', 'usercache',
                       value='/example/largefiles-store'),
             mock.call(model.global_settings, 'phases', 'publish',
                       value='False'),
             mock.call(model.global_settings, 'extensions', 'hgsubversion',
                       active=False)
         ]
         assert expected_calls == create_mock.call_args_list
 
     @pytest.mark.parametrize('field_to_remove', FORM_DATA.keys())
     def test_key_is_not_found(self, repo_stub, field_to_remove):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         data = self.FORM_DATA.copy()
         data.pop(field_to_remove)
         with pytest.raises(Exception) as exc_info:
             model.create_or_update_global_hg_settings(data)
         expected_message = 'The given data does not contain {} key'.format(
             field_to_remove)
         assert exc_info.value.message == expected_message
 
 
 class TestDeleteRepoSvnPattern(object):
     def test_success_when_repo_is_set(self, backend_svn):
         repo_name = backend_svn.repo_name
         model = VcsSettingsModel(repo=repo_name)
         delete_ui_patch = mock.patch.object(model.repo_settings, 'delete_ui')
         with delete_ui_patch as delete_ui_mock:
             model.delete_repo_svn_pattern(123)
         delete_ui_mock.assert_called_once_with(123)
 
     def test_raises_exception_when_repository_is_not_specified(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.delete_repo_svn_pattern(123)
         assert exc_info.value.message == 'Repository is not specified'
 
 
 class TestDeleteGlobalSvnPattern(object):
     def test_delete_global_svn_pattern_calls_delete_ui(self):
         model = VcsSettingsModel()
         delete_ui_patch = mock.patch.object(model.global_settings, 'delete_ui')
         with delete_ui_patch as delete_ui_mock:
             model.delete_global_svn_pattern(123)
         delete_ui_mock.assert_called_once_with(123)
 
 
 class TestFilterUiSettings(object):
     def test_settings_are_filtered(self):
         model = VcsSettingsModel()
         repo_settings = [
             UiSetting('extensions', 'largefiles', '', True),
             UiSetting('phases', 'publish', 'True', True),
             UiSetting('hooks', 'changegroup.repo_size', 'hook', True),
             UiSetting('hooks', 'changegroup.push_logger', 'hook', True),
             UiSetting('hooks', 'outgoing.pull_logger', 'hook', True),
             UiSetting(
                 'vcs_svn_branch', '84223c972204fa545ca1b22dac7bef5b68d7442d',
                 'test_branch', True),
             UiSetting(
                 'vcs_svn_tag', '84229c972204fa545ca1b22dac7bef5b68d7442d',
                 'test_tag', True),
         ]
         non_repo_settings = [
             UiSetting('largefiles', 'usercache', '/example/largefiles-store', True),
             UiSetting('test', 'outgoing.pull_logger', 'hook', True),
             UiSetting('hooks', 'test2', 'hook', True),
             UiSetting(
                 'vcs_svn_repo', '84229c972204fa545ca1b22dac7bef5b68d7442d',
                 'test_tag', True),
         ]
         settings = repo_settings + non_repo_settings
         filtered_settings = model._filter_ui_settings(settings)
         assert sorted(filtered_settings) == sorted(repo_settings)
 
 
 class TestFilterGeneralSettings(object):
     def test_settings_are_filtered(self):
         model = VcsSettingsModel()
         settings = {
             'rhodecode_abcde': 'value1',
             'rhodecode_vwxyz': 'value2',
         }
         general_settings = {
             'rhodecode_{}'.format(key): 'value'
             for key in VcsSettingsModel.GENERAL_SETTINGS
         }
         settings.update(general_settings)
 
         filtered_settings = model._filter_general_settings(general_settings)
         assert sorted(filtered_settings) == sorted(general_settings)
 
 
 class TestGetRepoUiSettings(object):
     def test_global_uis_are_returned_when_no_repo_uis_found(
             self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_repo_ui_settings()
         svn_sections = (
             VcsSettingsModel.SVN_TAG_SECTION,
             VcsSettingsModel.SVN_BRANCH_SECTION)
         expected_result = [
             s for s in model.global_settings.get_ui()
             if s.section not in svn_sections]
         assert sorted(result) == sorted(expected_result)
 
     def test_repo_uis_are_overriding_global_uis(
             self, repo_stub, settings_util):
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'repo', key=key, active=False)
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_repo_ui_settings()
         for setting in result:
             locator = (setting.section, setting.key)
             if locator in VcsSettingsModel.HOOKS_SETTINGS:
                 assert setting.value == 'repo'
 
                 assert setting.active is False
 
     def test_global_svn_patterns_are_not_in_list(
             self, repo_stub, settings_util):
         svn_sections = (
             VcsSettingsModel.SVN_TAG_SECTION,
             VcsSettingsModel.SVN_BRANCH_SECTION)
         for section in svn_sections:
             settings_util.create_rhodecode_ui(
                 section, 'repo', key='deadbeef' + section, active=False)
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_repo_ui_settings()
         for setting in result:
             assert setting.section not in svn_sections
 
     def test_repo_uis_filtered_by_section_are_returned(
             self, repo_stub, settings_util):
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'repo', key=key, active=False)
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         section, key = VcsSettingsModel.HOOKS_SETTINGS[0]
         result = model.get_repo_ui_settings(section=section)
         for setting in result:
             assert setting.section == section
 
     def test_repo_uis_filtered_by_key_are_returned(
             self, repo_stub, settings_util):
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'repo', key=key, active=False)
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         section, key = VcsSettingsModel.HOOKS_SETTINGS[0]
         result = model.get_repo_ui_settings(key=key)
         for setting in result:
             assert setting.key == key
 
     def test_raises_exception_when_repository_is_not_specified(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.get_repo_ui_settings()
         assert exc_info.value.message == 'Repository is not specified'
 
 
 class TestGetRepoGeneralSettings(object):
     def test_global_settings_are_returned_when_no_repo_settings_found(
             self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_repo_general_settings()
         expected_result = model.global_settings.get_all_settings()
         assert sorted(result) == sorted(expected_result)
 
     def test_repo_uis_are_overriding_global_uis(
             self, repo_stub, settings_util):
         for key in VcsSettingsModel.GENERAL_SETTINGS:
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, key, 'abcde', type_='unicode')
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_repo_ui_settings()
         for key in result:
             if key in VcsSettingsModel.GENERAL_SETTINGS:
                 assert result[key] == 'abcde'
 
     def test_raises_exception_when_repository_is_not_specified(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.get_repo_general_settings()
         assert exc_info.value.message == 'Repository is not specified'
 
 
 class TestGetGlobalGeneralSettings(object):
     def test_global_settings_are_returned(self, repo_stub):
         model = VcsSettingsModel()
         result = model.get_global_general_settings()
         expected_result = model.global_settings.get_all_settings()
         assert sorted(result) == sorted(expected_result)
 
     def test_repo_uis_are_not_overriding_global_uis(
             self, repo_stub, settings_util):
         for key in VcsSettingsModel.GENERAL_SETTINGS:
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, key, 'abcde', type_='unicode')
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_global_general_settings()
         expected_result = model.global_settings.get_all_settings()
         assert sorted(result) == sorted(expected_result)
 
 
 class TestGetGlobalUiSettings(object):
     def test_global_uis_are_returned(self, repo_stub):
         model = VcsSettingsModel()
         result = model.get_global_ui_settings()
         expected_result = model.global_settings.get_ui()
         assert sorted(result) == sorted(expected_result)
 
     def test_repo_uis_are_not_overriding_global_uis(
             self, repo_stub, settings_util):
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'repo', key=key, active=False)
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         result = model.get_global_ui_settings()
         expected_result = model.global_settings.get_ui()
         assert sorted(result) == sorted(expected_result)
 
     def test_ui_settings_filtered_by_section(
             self, repo_stub, settings_util):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         section, key = VcsSettingsModel.HOOKS_SETTINGS[0]
         result = model.get_global_ui_settings(section=section)
         expected_result = model.global_settings.get_ui(section=section)
         assert sorted(result) == sorted(expected_result)
 
     def test_ui_settings_filtered_by_key(
             self, repo_stub, settings_util):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         section, key = VcsSettingsModel.HOOKS_SETTINGS[0]
         result = model.get_global_ui_settings(key=key)
         expected_result = model.global_settings.get_ui(key=key)
         assert sorted(result) == sorted(expected_result)
 
 
 class TestGetGeneralSettings(object):
     def test_global_settings_are_returned_when_inherited_is_true(
             self, repo_stub, settings_util):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model.inherit_global_settings = True
         for key in VcsSettingsModel.GENERAL_SETTINGS:
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, key, 'abcde', type_='unicode')
         result = model.get_general_settings()
         expected_result = model.get_global_general_settings()
         assert sorted(result) == sorted(expected_result)
 
     def test_repo_settings_are_returned_when_inherited_is_false(
             self, repo_stub, settings_util):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model.inherit_global_settings = False
         for key in VcsSettingsModel.GENERAL_SETTINGS:
             settings_util.create_repo_rhodecode_setting(
                 repo_stub, key, 'abcde', type_='unicode')
         result = model.get_general_settings()
         expected_result = model.get_repo_general_settings()
         assert sorted(result) == sorted(expected_result)
 
     def test_global_settings_are_returned_when_no_repository_specified(self):
         model = VcsSettingsModel()
         result = model.get_general_settings()
         expected_result = model.get_global_general_settings()
         assert sorted(result) == sorted(expected_result)
 
 
 class TestGetUiSettings(object):
     def test_global_settings_are_returned_when_inherited_is_true(
             self, repo_stub, settings_util):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model.inherit_global_settings = True
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'repo', key=key, active=True)
         result = model.get_ui_settings()
         expected_result = model.get_global_ui_settings()
         assert sorted(result) == sorted(expected_result)
 
     def test_repo_settings_are_returned_when_inherited_is_false(
             self, repo_stub, settings_util):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model.inherit_global_settings = False
         for section, key in VcsSettingsModel.HOOKS_SETTINGS:
             settings_util.create_repo_rhodecode_ui(
                 repo_stub, section, 'repo', key=key, active=True)
         result = model.get_ui_settings()
         expected_result = model.get_repo_ui_settings()
         assert sorted(result) == sorted(expected_result)
 
     def test_repo_settings_filtered_by_section_and_key(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         model.inherit_global_settings = False
         args = ('section', 'key')
         with mock.patch.object(model, 'get_repo_ui_settings') as settings_mock:
             model.get_ui_settings(*args)
         settings_mock.assert_called_once_with(*args)
 
     def test_global_settings_filtered_by_section_and_key(self):
         model = VcsSettingsModel()
         args = ('section', 'key')
         with mock.patch.object(model, 'get_global_ui_settings') as (
                 settings_mock):
             model.get_ui_settings(*args)
         settings_mock.assert_called_once_with(*args)
 
     def test_global_settings_are_returned_when_no_repository_specified(self):
         model = VcsSettingsModel()
         result = model.get_ui_settings()
         expected_result = model.get_global_ui_settings()
         assert sorted(result) == sorted(expected_result)
 
 
 class TestGetSvnPatterns(object):
     def test_repo_settings_filtered_by_section_and_key(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub.repo_name)
         args = ('section', )
         with mock.patch.object(model, 'get_repo_ui_settings') as settings_mock:
             model.get_svn_patterns(*args)
         settings_mock.assert_called_once_with(*args)
 
     def test_global_settings_filtered_by_section_and_key(self):
         model = VcsSettingsModel()
         args = ('section', )
         with mock.patch.object(model, 'get_global_ui_settings') as (
                 settings_mock):
             model.get_svn_patterns(*args)
         settings_mock.assert_called_once_with(*args)
 
 
 class TestGetReposLocation(object):
     def test_returns_repos_location(self, repo_stub):
         model = VcsSettingsModel()
 
         result_mock = mock.Mock()
         result_mock.ui_value = '/tmp'
 
         with mock.patch.object(model, 'global_settings') as settings_mock:
             settings_mock.get_ui_by_key.return_value = result_mock
             result = model.get_repos_location()
 
         settings_mock.get_ui_by_key.assert_called_once_with('/')
         assert result == '/tmp'
 
 
 class TestCreateOrUpdateRepoSettings(object):
     FORM_DATA = {
         'inherit_global_settings': False,
         'hooks_changegroup_repo_size': False,
         'hooks_changegroup_push_logger': False,
         'hooks_outgoing_pull_logger': False,
         'extensions_largefiles': False,
         'largefiles_usercache': '/example/largefiles-store',
-        'phases_publish': 'false',
+        'phases_publish': 'False',
         'rhodecode_pr_merge_enabled': False,
         'rhodecode_use_outdated_comments': False,
         'new_svn_branch': '',
         'new_svn_tag': ''
     }
 
     def test_get_raises_exception_when_repository_not_specified(self):
         model = VcsSettingsModel()
         with pytest.raises(Exception) as exc_info:
             model.create_or_update_repo_settings(data=self.FORM_DATA)
         assert exc_info.value.message == 'Repository is not specified'
 
     def test_only_svn_settings_are_updated_when_type_is_svn(self, backend_svn):
         repo = backend_svn.create_repo()
         model = VcsSettingsModel(repo=repo)
         with self._patch_model(model) as mocks:
             model.create_or_update_repo_settings(
                 data=self.FORM_DATA, inherit_global_settings=False)
         mocks['create_repo_svn_settings'].assert_called_once_with(
             self.FORM_DATA)
         non_called_methods = (
             'create_or_update_repo_hook_settings',
             'create_or_update_repo_pr_settings',
             'create_or_update_repo_hg_settings')
         for method in non_called_methods:
             assert mocks[method].call_count == 0
 
     def test_non_svn_settings_are_updated_when_type_is_hg(self, backend_hg):
         repo = backend_hg.create_repo()
         model = VcsSettingsModel(repo=repo)
         with self._patch_model(model) as mocks:
             model.create_or_update_repo_settings(
                 data=self.FORM_DATA, inherit_global_settings=False)
 
         assert mocks['create_repo_svn_settings'].call_count == 0
         called_methods = (
             'create_or_update_repo_hook_settings',
             'create_or_update_repo_pr_settings',
             'create_or_update_repo_hg_settings')
         for method in called_methods:
             mocks[method].assert_called_once_with(self.FORM_DATA)
 
     def test_non_svn_and_hg_settings_are_updated_when_type_is_git(
             self, backend_git):
         repo = backend_git.create_repo()
         model = VcsSettingsModel(repo=repo)
         with self._patch_model(model) as mocks:
             model.create_or_update_repo_settings(
                 data=self.FORM_DATA, inherit_global_settings=False)
 
         assert mocks['create_repo_svn_settings'].call_count == 0
         called_methods = (
             'create_or_update_repo_hook_settings',
             'create_or_update_repo_pr_settings')
         non_called_methods = (
             'create_repo_svn_settings',
             'create_or_update_repo_hg_settings'
         )
         for method in called_methods:
             mocks[method].assert_called_once_with(self.FORM_DATA)
         for method in non_called_methods:
             assert mocks[method].call_count == 0
 
     def test_no_methods_are_called_when_settings_are_inherited(
             self, backend):
         repo = backend.create_repo()
         model = VcsSettingsModel(repo=repo)
         with self._patch_model(model) as mocks:
             model.create_or_update_repo_settings(
                 data=self.FORM_DATA, inherit_global_settings=True)
         for method_name in mocks:
             assert mocks[method_name].call_count == 0
 
     def test_cache_is_marked_for_invalidation(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub)
         invalidation_patcher = mock.patch(
             'rhodecode.controllers.admin.repos.ScmModel.mark_for_invalidation')
         with invalidation_patcher as invalidation_mock:
             model.create_or_update_repo_settings(
                 data=self.FORM_DATA, inherit_global_settings=True)
         invalidation_mock.assert_called_once_with(
             repo_stub.repo_name, delete=True)
 
     def test_inherit_flag_is_saved(self, repo_stub):
         model = VcsSettingsModel(repo=repo_stub)
         model.inherit_global_settings = True
         with self._patch_model(model):
             model.create_or_update_repo_settings(
                 data=self.FORM_DATA, inherit_global_settings=False)
         assert model.inherit_global_settings is False
 
     def _patch_model(self, model):
         return mock.patch.multiple(
             model,
             create_repo_svn_settings=mock.DEFAULT,
             create_or_update_repo_hook_settings=mock.DEFAULT,
             create_or_update_repo_pr_settings=mock.DEFAULT,
             create_or_update_repo_hg_settings=mock.DEFAULT)