##// END OF EJS Templates
api: added last-activity into returned data of get_user api....
api: added last-activity into returned data of get_user api. - refs #5256

File last commit:

r1271:47a44c03 default
r1558:107da576 default
Show More
test_settings.py
807 lines | 28.7 KiB | text/x-python | PythonLexer
# -*- 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 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)
]