|
|
# Copyright (C) 2010-2024 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 str(exc_info.value) == 'Setting `{}` is not found'.format(id_)
|
|
|
|
|
|
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)
|
|
|
]
|
|
|
|
