rhodecode/tests/models/settings/test_settings.py

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

# Copyright (C) 2010-2016  RhodeCode GmbH
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License, version 3
# (only), as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
# This program is dual-licensed. If you wish to learn more about the
# RhodeCode Enterprise Edition, including its added features, Support services,
# and proprietary license terms, please see https://rhodecode.com/licenses/

import mock
import pytest

from rhodecode.lib.utils2 import safe_str
from rhodecode.model.db import (
    RhodeCodeUi, RepoRhodeCodeUi, RhodeCodeSetting, RepoRhodeCodeSetting)
from rhodecode.model.meta import Session
from rhodecode.model.settings import SettingsModel, SettingNotFound, UiSetting


class TestRepoGetUiByKey(object):
    def test_ui_settings_are_returned_when_key_is_found(
            self, repo_stub, settings_util):
        section = 'test section'
        value = 'test value'

        settings_util.create_repo_rhodecode_ui(
            repo_stub, 'wrong section', 'wrong value')
        setting = settings_util.create_repo_rhodecode_ui(
            repo_stub, section, value)
        key = setting.ui_key

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_ui_by_key(key)
        assert result.ui_value == value
        assert result.ui_section == section
        assert result.ui_active is True

    def test_none_is_returned_when_key_is_not_found(
            self, repo_stub, settings_util):
        settings_util.create_repo_rhodecode_ui(
            repo_stub, 'wrong section', 'wrong value')

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_ui_by_key('abcde')
        assert result is None


class TestGlobalGetUiByKey(object):
    def test_ui_settings_are_returned_when_key_is_found(self, settings_util):
        section = 'test section'
        value = 'test value'

        settings_util.create_rhodecode_ui('wrong section', 'wrong value')
        setting = settings_util.create_rhodecode_ui(section, value)
        key = setting.ui_key

        model = SettingsModel()
        result = model.get_ui_by_key(key)
        assert result.ui_value == value
        assert result.ui_section == section
        assert result.ui_active is True

    def test_none_is_returned_when_key_is_not_found(self, settings_util):
        settings_util.create_rhodecode_ui('wrong section', 'wrong value')
        model = SettingsModel()
        result = model.get_ui_by_key('abcde')
        assert result is None


class TestRepoGetUiBySection(object):
    def test_ui_settings_are_returned_when_section_is_found(
            self, repo_stub, settings_util):
        section = 'test section'
        values = ['test value 1', 'test value 2']

        expected_pairs = []
        for value in values:
            setting = settings_util.create_repo_rhodecode_ui(
                repo_stub, section, value)
            expected_pairs.append((setting.ui_key, value))

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_ui_by_section(section)
        result_pairs = [(r.ui_key, r.ui_value) for r in result]
        assert sorted(result_pairs) == sorted(expected_pairs)

    def test_empty_list_is_returned_when_section_is_not_found(
            self, repo_stub, settings_util):
        settings_util.create_repo_rhodecode_ui(
            repo_stub, 'wrong section', 'wrong value')

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_ui_by_section('correct section')
        assert result == []


class TestGlobalGetUiBySection(object):
    def test_ui_settings_are_returned_when_section_is_found(
            self, settings_util):
        section = 'test section'
        values = ['test value 1', 'test value 2']

        expected_pairs = []
        for value in values:
            setting = settings_util.create_rhodecode_ui(section, value)
            expected_pairs.append((setting.ui_key, value))

        model = SettingsModel()
        result = model.get_ui_by_section(section)
        result_pairs = [(r.ui_key, r.ui_value) for r in result]
        assert sorted(result_pairs) == sorted(expected_pairs)

    def test_empty_list_is_returned_when_section_is_not_found(
            self, settings_util):
        settings_util.create_rhodecode_ui('wrong section', 'wrong value')

        model = SettingsModel()
        result = model.get_ui_by_section('correct section')
        assert result == []


class TestRepoGetUiBySectionAndKey(object):
    def test_ui_settings_are_returned_when_section_and_key_are_found(
            self, repo_stub, settings_util):
        section = 'test section'
        value = 'test value'
        key = 'test key'

        settings_util.create_rhodecode_ui(
            'wrong section', 'wrong value', key='wrong key')
        setting = settings_util.create_repo_rhodecode_ui(
            repo_stub, section, value, key=key)
        key = setting.ui_key

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_ui_by_section_and_key(section, key)
        assert result.ui_value == value
        assert result.ui_section == section
        assert result.ui_active is True

    def test_none_is_returned_when_key_section_pair_is_not_found(
            self, repo_stub, settings_util):
        settings_util.create_repo_rhodecode_ui(
            repo_stub, 'section', 'wrong value', key='wrong key')

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_ui_by_section_and_key('section', 'test key')
        assert result is None


class TestGlobalGetUiBySectionAndKey(object):
    def test_ui_settings_are_returned_when_section_and_key_are_found(
            self, settings_util):
        section = 'test section'
        value = 'test value'
        key = 'test key'

        settings_util.create_rhodecode_ui(
            'wrong section', 'wrong value', key='wrong key')
        setting = settings_util.create_rhodecode_ui(section, value, key=key)
        key = setting.ui_key

        model = SettingsModel()
        result = model.get_ui_by_section_and_key(section, key)
        assert result.ui_value == value
        assert result.ui_section == section
        assert result.ui_active is True

    def test_none_is_returned_when_key_section_pair_is_not_found(
            self, settings_util):
        settings_util.create_rhodecode_ui(
            'section', 'wrong value', key='wrong key')
        model = SettingsModel()
        result = model.get_ui_by_section_and_key('section', 'test key')
        assert result is None


class TestRepoGetUi(object):
    def test_non_empty_list_is_returned_when_ui_settings_found(
            self, repo_stub, settings_util, fake_ui_values):
        for ui in fake_ui_values:
            settings_util.create_repo_rhodecode_ui(
                repo_stub, ui.section, ui.value, key=ui.key)
            # Create few global settings to check that only repo ones are
            # displayed
            settings_util.create_rhodecode_ui(ui.section, ui.value, key=ui.key)

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_ui()
        assert sorted(result) == sorted(fake_ui_values)

    def test_settings_filtered_by_section(
            self, repo_stub, settings_util, fake_ui_values):
        for ui in fake_ui_values:
            settings_util.create_repo_rhodecode_ui(
                repo_stub, ui.section, ui.value, key=ui.key)

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_ui(section=fake_ui_values[0].section)
        expected_result = [
            s for s in fake_ui_values
            if s.section == fake_ui_values[0].section]
        assert sorted(result) == sorted(expected_result)

    def test_settings_filtered_by_key(
            self, repo_stub, settings_util, fake_ui_values):
        for ui in fake_ui_values:
            settings_util.create_repo_rhodecode_ui(
                repo_stub, ui.section, ui.value, key=ui.key)

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_ui(key=fake_ui_values[0].key)
        expected_result = [
            s for s in fake_ui_values if s.key == fake_ui_values[0].key]
        assert sorted(result) == sorted(expected_result)

    def test_empty_list_is_returned_when_ui_settings_are_not_found(
            self, repo_stub, settings_util):
        for i in range(10):
            settings_util.create_rhodecode_ui(
                'section{}'.format(i), 'value{}'.format(i),
                key='key{}'.format(i), active=True)

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_ui()
        assert result == []


class TestGlobalGetUi(object):
    def test_non_empty_list_is_returned_when_ui_settings_found(
            self, backend_stub, settings_util, fake_ui_values):
        repo = backend_stub.create_repo()
        for ui in fake_ui_values:
            settings_util.create_rhodecode_ui(ui.section, ui.value, key=ui.key)
            # Create few repo settings to check that only global ones are
            # displayed
            settings_util.create_repo_rhodecode_ui(
                repo, ui.section, ui.value, key=ui.key)

        model = SettingsModel()
        result = model.get_ui()
        for ui in fake_ui_values:
            assert ui in result

    def test_settings_filtered_by_key(self, settings_util, fake_ui_values):
        for ui in fake_ui_values:
            settings_util.create_rhodecode_ui(ui.section, ui.value, key=ui.key)
        expected_result = [
            s for s in fake_ui_values if s.key == fake_ui_values[0].key]

        model = SettingsModel()
        result = model.get_ui(key=fake_ui_values[0].key)
        assert sorted(result) == sorted(expected_result)

    def test_settings_filtered_by_section(self, settings_util, fake_ui_values):
        for ui in fake_ui_values:
            settings_util.create_rhodecode_ui(ui.section, ui.value, key=ui.key)
        expected_result = [
            s for s in fake_ui_values
            if s.section == fake_ui_values[0].section]

        model = SettingsModel()
        result = model.get_ui(section=fake_ui_values[0].section)
        assert sorted(result) == sorted(expected_result)

    def test_repo_settings_are_not_displayed(
            self, backend_stub, settings_util, fake_ui_values):
        repo = backend_stub.create_repo()
        for ui in fake_ui_values:
            settings_util.create_repo_rhodecode_ui(
                repo, ui.section, ui.value, key=ui.key, active=ui.active)

        model = SettingsModel()
        result = model.get_ui()
        for ui in fake_ui_values:
            assert ui not in result


class TestRepoGetBuiltInHooks(object):
    def test_only_builtin_hooks_are_returned(self, repo_stub, settings_util):
        section = 'hooks'
        valid_keys = SettingsModel.BUILTIN_HOOKS
        invalid_keys = ('fake_hook', )
        keys = valid_keys + invalid_keys

        for key in keys:
            settings_util.create_repo_rhodecode_ui(
                repo_stub, section, 'test value', key=key)

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_builtin_hooks()

        assert len(result) == len(valid_keys)
        for entry in result:
            assert entry.ui_key in valid_keys


class TestGlobalGetBuiltInHooks(object):
    def test_only_builtin_hooks_are_returned(self, settings_util):
        section = 'hooks'
        valid_keys = ('valid_key1', 'valid_key2')
        invalid_keys = ('fake_hook', )
        keys = valid_keys + invalid_keys

        for key in keys:
            settings_util.create_rhodecode_ui(section, 'test value', key=key)

        model = SettingsModel()
        with mock.patch.object(model, 'BUILTIN_HOOKS', valid_keys):
            result = model.get_builtin_hooks()

        assert len(result) == len(valid_keys)
        for entry in result:
            assert entry.ui_key in valid_keys


class TestRepoGetCustomHooks(object):
    def test_only_custom_hooks_are_returned(self, repo_stub, settings_util):
        section = 'hooks'
        valid_keys = ('custom', )
        invalid_keys = SettingsModel.BUILTIN_HOOKS
        keys = valid_keys + invalid_keys

        for key in keys:
            settings_util.create_repo_rhodecode_ui(
                repo_stub, section, 'test value', key=key)

        model = SettingsModel(repo=repo_stub.repo_name)
        result = model.get_custom_hooks()

        assert len(result) == len(valid_keys)
        for entry in result:
            assert entry.ui_key in valid_keys


class TestGlobalGetCustomHooks(object):
    def test_only_custom_hooks_are_returned(self, settings_util):
        section = 'hooks'
        valid_keys = ('valid_key1', 'valid_key2')
        invalid_keys = ('fake_hook', )
        keys = valid_keys + invalid_keys

        for key in keys:
            settings_util.create_rhodecode_ui(section, 'test value', key=key)

        model = SettingsModel()
        with mock.patch.object(model, 'BUILTIN_HOOKS', invalid_keys):
            result = model.get_custom_hooks()
        for entry in result:
            assert entry.ui_key not in invalid_keys


class TestRepoCreateUiSectionValue(object):
    @pytest.mark.parametrize("additional_kwargs", [
        {'key': 'abcde'},
        {'active': False},
        {}
    ])
    def test_ui_section_value_is_created(
            self, repo_stub, additional_kwargs):
        model = SettingsModel(repo=repo_stub.repo_name)
        section = 'test section'
        value = 'test value'
        result = model.create_ui_section_value(section, value)
        key = result.ui_key
        Session().commit()

        setting = model.get_ui_by_key(key)
        try:
            assert setting == result
            assert isinstance(setting, RepoRhodeCodeUi)
        finally:
            Session().delete(result)
            Session().commit()


class TestGlobalCreateUiSectionValue(object):
    @pytest.mark.parametrize("additional_kwargs", [
        {'key': 'abcde'},
        {'active': False},
        {}
    ])
    def test_ui_section_value_is_created_with_autogenerated_key(
            self, backend_stub, additional_kwargs):
        model = SettingsModel()
        section = 'test section'
        value = 'test value'
        result = model.create_ui_section_value(
            section, value, **additional_kwargs)
        key = result.ui_key
        Session().commit()

        setting = model.get_ui_by_key(key)
        try:
            assert setting == result
            assert isinstance(setting, RhodeCodeUi)
        finally:
            Session().delete(result)
            Session().commit()


class TestRepoCreateOrUpdateHook(object):
    def test_hook_created(self, repo_stub):
        model = SettingsModel(repo=repo_stub.repo_name)
        key = 'test_key'
        value = 'test value'
        result = model.create_or_update_hook(key, value)
        Session().commit()

        setting = model.get_ui_by_section_and_key('hooks', key)
        try:
            assert setting == result
            assert isinstance(setting, RepoRhodeCodeUi)
        finally:
            Session().delete(result)
            Session().commit()

    def test_hook_updated(self, repo_stub, settings_util):
        section = 'hooks'
        key = 'test_key'

        settings_util.create_repo_rhodecode_ui(
            repo_stub, section, 'old value', key=key)

        model = SettingsModel(repo=repo_stub.repo_name)
        value = 'test value'
        model.create_or_update_hook(key, value)
        Session().commit()

        setting = model.get_ui_by_section_and_key('hooks', key)
        assert setting.ui_value == value


class TestGlobalCreateOrUpdateHook(object):
    def test_hook_created(self):
        model = SettingsModel()
        key = 'test_key'
        value = 'test value'
        result = model.create_or_update_hook(key, value)
        Session().commit()

        setting = model.get_ui_by_section_and_key('hooks', key)
        try:
            assert setting == result
            assert isinstance(setting, RhodeCodeUi)
        finally:
            Session().delete(result)
            Session().commit()

    def test_hook_updated(self, settings_util):
        section = 'hooks'
        key = 'test_key'

        settings_util.create_rhodecode_ui(section, 'old value', key=key)

        model = SettingsModel()
        value = 'test value'
        model.create_or_update_hook(key, value)
        Session().commit()

        setting = model.get_ui_by_section_and_key('hooks', key)
        assert setting.ui_value == value


class TestDeleteUiValue(object):
    def test_delete_ui_when_repo_is_set(self, repo_stub, settings_util):
        model = SettingsModel(repo=repo_stub.repo_name)
        result = settings_util.create_repo_rhodecode_ui(
            repo_stub, 'section', None, cleanup=False)

        key = result.ui_key
        model.delete_ui(result.ui_id)
        Session().commit()

        setting = model.get_ui_by_key(key)
        assert setting is None

    @pytest.mark.parametrize('id_', (None, 123))
    def test_raises_exception_when_id_is_not_specified(self, id_):
        model = SettingsModel()
        with pytest.raises(SettingNotFound) as exc_info:
            model.delete_ui(id_)
        assert exc_info.value.message == 'Setting is not found'

    def test_delete_ui_when_repo_is_not_set(self, settings_util):
        model = SettingsModel()
        result = settings_util.create_rhodecode_ui(
            'section', None, cleanup=False)

        key = result.ui_key
        model.delete_ui(result.ui_id)
        Session().commit()

        setting = model.get_ui_by_key(key)
        assert setting is None


class TestRepoGetSettingByName(object):
    @pytest.mark.parametrize("name, value, type_, expected_value", [
        ('test_unicode', 'Straße', 'unicode', 'Straße'),
        ('test_int', '1234', 'int', 1234),
        ('test_bool', 'True', 'bool', True),
        ('test_list', 'a,b,c', 'list', ['a', 'b', 'c'])
    ])
    def test_setting_is_returned_when_name_is_found(
            self, repo_stub, settings_util, name, value, type_,
            expected_value):
        settings_util.create_repo_rhodecode_setting(
            repo_stub, name, value, type_)

        model = SettingsModel(repo=repo_stub.repo_name)
        setting = model.get_setting_by_name(name)
        assert setting.app_settings_type == type_
        actual_value = setting.app_settings_value
        if type_ == 'unicode':
            actual_value = safe_str(actual_value)
        assert actual_value == expected_value

    def test_returns_none_if_the_setting_does_not_exist(self, repo_stub):
        model = SettingsModel(repo=repo_stub.repo_name)
        setting = model.get_setting_by_name('abcde')
        assert setting is None


class TestGlobalGetSettingByName(object):
    @pytest.mark.parametrize("name, value, type_, expected_value", [
        ('test_unicode', 'Straße', 'unicode', 'Straße'),
        ('test_int', '1234', 'int', 1234),
        ('test_bool', 'True', 'bool', True),
        ('test_list', 'a,b,c', 'list', ['a', 'b', 'c'])
    ])
    def test_setting_is_returned_when_name_is_found(
            self, settings_util, name, value, type_, expected_value):
        settings_util.create_rhodecode_setting(name, value, type_)

        model = SettingsModel()
        setting = model.get_setting_by_name(name)
        assert setting.app_settings_type == type_
        actual_value = setting.app_settings_value
        if type_ == 'unicode':
            actual_value = safe_str(actual_value)
        assert actual_value == expected_value

    def test_returns_none_if_the_setting_does_not_exist(self):
        model = SettingsModel()
        setting = model.get_setting_by_name('abcde')
        assert setting is None


class TestRepoGetAllSettings(object):
    def test_settings_are_found(self, repo_stub, settings_util):
        initial_settings = {
            'test_setting_{}'.format(i): 'value' for i in range(10)}
        settings = [
            settings_util.create_repo_rhodecode_setting(
                repo_stub, name, initial_settings[name], 'unicode')
            for name in initial_settings
        ]
        model = SettingsModel(repo=repo_stub.repo_name)

        settings = model.get_all_settings()
        expected_settings = {
            'rhodecode_' + name: initial_settings[name]
            for name in initial_settings
        }

        assert len(settings) == 10
        assert expected_settings == settings

    def test_settings_are_not_found(self, repo_stub):
        model = SettingsModel(repo=repo_stub.repo_name)
        setting = model.get_all_settings()
        assert setting == {}


class TestGlobalGetAllSettings(object):
    def test_settings_are_found(self, settings_util):
        initial_settings = {
            'test_setting_{}'.format(i): 'value' for i in range(10)}
        settings = [
            settings_util.create_rhodecode_setting(
                name, initial_settings[name], 'unicode')
            for name in initial_settings
        ]
        model = SettingsModel()

        settings = model.get_all_settings()
        expected_settings = {
            'rhodecode_' + name: initial_settings[name]
            for name in initial_settings
        }

        filtered_settings = {
            name: settings[name]
            for name in settings if name.startswith('rhodecode_test_setting')
        }
        assert len(filtered_settings) == 10
        assert expected_settings == filtered_settings

    def test_settings_are_not_found(self, repo_stub):
        model = SettingsModel(repo=repo_stub.repo_name)
        setting = model.get_all_settings()
        assert setting == {}


class TestRepoCreateOrUpdateSetting(object):
    def test_setting_is_created(self, repo_stub):
        model = SettingsModel(repo=repo_stub.repo_name)
        name = 'test_setting'
        value = 'test_value'
        model.create_or_update_setting(name, val=value)

        setting = model.get_setting_by_name(name)
        try:
            assert setting.app_settings_name == name
            assert setting.app_settings_value == value
            assert setting.app_settings_type == 'unicode'
            assert isinstance(setting, RepoRhodeCodeSetting)
        finally:
            Session().delete(setting)
            Session().commit()

    def test_setting_is_updated(self, repo_stub, settings_util):
        model = SettingsModel(repo=repo_stub.repo_name)
        name = 'test_setting'
        value = 'test_value'
        settings_util.create_repo_rhodecode_setting(
            repo_stub, name, value, 'unicode', cleanup=False)

        updated_value = 'test_value_2'
        model.create_or_update_setting(name, val=updated_value)

        setting = model.get_setting_by_name(name)
        try:
            assert setting.app_settings_name == name
            assert setting.app_settings_value == updated_value
            assert setting.app_settings_type == 'unicode'
            assert isinstance(setting, RepoRhodeCodeSetting)
        finally:
            Session().delete(setting)
            Session().commit()


class TestGlobalCreateOrUpdateSetting(object):
    def test_setting_is_created(self):
        model = SettingsModel()
        name = 'test_setting'
        value = 'test_value'
        model.create_or_update_setting(name, val=value)

        setting = model.get_setting_by_name(name)
        try:
            assert setting.app_settings_name == name
            assert setting.app_settings_value == value
            assert setting.app_settings_type == 'unicode'
            assert isinstance(setting, RhodeCodeSetting)
        finally:
            Session().delete(setting)
            Session().commit()

    def test_setting_is_updated(self, settings_util):
        model = SettingsModel()
        name = 'test_setting'
        value = 'test_value'
        settings_util.create_rhodecode_setting(
            name, value, 'unicode', cleanup=False)

        updated_value = 'test_value_2'
        model.create_or_update_setting(name, val=updated_value)

        setting = model.get_setting_by_name(name)
        try:
            assert setting.app_settings_name == name
            assert setting.app_settings_value == updated_value
            assert setting.app_settings_type == 'unicode'
            assert isinstance(setting, RhodeCodeSetting)
        finally:
            Session().delete(setting)
            Session().commit()


class TestRepoGetAuthSettings(object):
    def test_settings_prefixed_with_auth_are_retured(
            self, repo_stub, settings_util):
        model = SettingsModel(repo=repo_stub.repo_name)
        valid_settings = ('auth_test1', 'auth_test2')
        invalid_settings = ('test1', 'test2')
        fake_value = 'test_value'

        for name in valid_settings + invalid_settings:
            settings_util.create_repo_rhodecode_setting(
                repo_stub, name, fake_value, 'unicode')

        auth_settings = model.get_auth_settings()
        assert auth_settings == {name: fake_value for name in valid_settings}


class TestGlobalGetAuthSettings(object):
    def test_settings_prefixed_with_auth_are_retured(self, settings_util):
        model = SettingsModel()
        valid_settings = ('auth_test1', 'auth_test2')
        invalid_settings = ('test1', 'test2')
        fake_value = 'test_value'

        for name in valid_settings + invalid_settings:
            settings_util.create_rhodecode_setting(name, fake_value, 'unicode')

        auth_settings = model.get_auth_settings()
        for name in auth_settings:
            assert name not in invalid_settings
            if name in valid_settings:
                assert auth_settings[name] == fake_value


class TestGetAuthPlugins(object):
    def test_get_setting_by_name_is_called(self):
        model = SettingsModel()

        fake_value = 'some value'
        result_mock = mock.Mock()
        result_mock.app_settings_value = fake_value

        get_setting_patch = mock.patch.object(
            model, 'get_setting_by_name', return_value=result_mock)

        with get_setting_patch as get_setting_mock:
            result = model.get_auth_plugins()

        get_setting_mock.assert_called_once_with('auth_plugins')
        assert result == fake_value


class TestDefaultRepoSettings(object):
    DEFAULT_SETTINGS_NAMES = ['default_a{}'.format(i) for i in range(10)]
    CUSTOM_SETTINGS_NAMES = ['setting_b_{}'.format(i) for i in range(10)]

    def test_returns_global_settings_prefixed_with_default(
            self, settings_util):
        self._create_values(settings_util)
        model = SettingsModel()
        result = model.get_default_repo_settings()
        self._assert_prefixed_settings(result)

    def test_returns_global_settings_without_default_prefix(
            self, settings_util):
        self._create_values(settings_util)
        model = SettingsModel()
        result = model.get_default_repo_settings(strip_prefix=True)
        self._assert_non_prefixed_settings(result)

    def test_returns_per_repo_settings_prefixed_with_default(
            self, repo_stub, settings_util):
        model = SettingsModel(repo=repo_stub)
        self._create_values(settings_util, repo=repo_stub)
        result = model.get_default_repo_settings()
        self._assert_prefixed_settings(result)

    def test_returns_per_repo_settings_without_default_prefix(
            self, repo_stub, settings_util):
        model = SettingsModel(repo=repo_stub)
        self._create_values(settings_util, repo=repo_stub)
        result = model.get_default_repo_settings(strip_prefix=True)
        self._assert_non_prefixed_settings(result)

    def _create_values(self, settings_util, repo=None):
        for name in self.DEFAULT_SETTINGS_NAMES + self.CUSTOM_SETTINGS_NAMES:
            if not repo:
                settings_util.create_rhodecode_setting(
                    name, 'value', 'unicode')
            else:
                settings_util.create_repo_rhodecode_setting(
                    repo, name, 'value', 'unicode')

    def _assert_prefixed_settings(self, result):
        for setting in self.DEFAULT_SETTINGS_NAMES:
            assert setting in result
            assert result[setting] == 'value'

        for setting in self.CUSTOM_SETTINGS_NAMES:
            assert setting not in result

    def _assert_non_prefixed_settings(self, result):
        for setting in self.DEFAULT_SETTINGS_NAMES:
            setting = setting.replace('default_', '')
            assert setting in result
            assert result[setting] == 'value'


@pytest.fixture
def fake_ui_values():
    return [
        UiSetting(
            'section{}'.format(i % 2), 'key{}'.format(i),
            'value{}'.format(i), True)
        for i in range(10)
    ]