Compare commits
1 commit
1d18cc74b7
...
a05d4e17a3
| Author | SHA1 | Date | |
|---|---|---|---|
| a05d4e17a3 |
32 changed files with 2398 additions and 2412 deletions
|
|
@ -856,31 +856,31 @@ def autocheck_reset_value_permissive(cfg, mcfg, pathread, pathwrite, confread, c
|
|||
_autocheck_default_value(cfg, pathread, confread, **kwargs)
|
||||
if confread != confwrite:
|
||||
_autocheck_default_value(cfg, pathwrite, confwrite, **kwargs)
|
||||
#FIXME
|
||||
#FIXME
|
||||
#FIXME@autocheck
|
||||
#FIXMEdef autocheck_display(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
|
||||
#FIXME """re set value
|
||||
#FIXME """
|
||||
#FIXME if kwargs['callback']:
|
||||
#FIXME return
|
||||
#FIXME make_dict = kwargs['make_dict']
|
||||
#FIXME make_dict_value = kwargs['make_dict_value']
|
||||
#FIXME if confread is not None:
|
||||
#FIXME cfg_ = cfg.config(confread)
|
||||
#FIXME else:
|
||||
#FIXME cfg_ = cfg
|
||||
#FIXME if confwrite is not None:
|
||||
#FIXME cfg2_ = cfg.config(confwrite)
|
||||
#FIXME else:
|
||||
#FIXME cfg2_ = cfg
|
||||
#FIXME assert cfg_.value.dict() == make_dict
|
||||
#FIXME if confread != confwrite:
|
||||
#FIXME assert(cfg2_.value.dict()) == make_dict
|
||||
#FIXME _set_value(cfg, pathwrite, confwrite, **kwargs)
|
||||
#FIXME assert cfg_.value.dict() == make_dict_value
|
||||
#FIXME if confread != confwrite:
|
||||
#FIXME assert(cfg2_.value.dict()) == make_dict_value
|
||||
|
||||
|
||||
@autocheck
|
||||
def autocheck_display(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
|
||||
"""re set value
|
||||
"""
|
||||
if kwargs['callback']:
|
||||
return
|
||||
make_dict = kwargs['make_dict']
|
||||
make_dict_value = kwargs['make_dict_value']
|
||||
if confread is not None:
|
||||
cfg_ = cfg.config(confread)
|
||||
else:
|
||||
cfg_ = cfg
|
||||
if confwrite is not None:
|
||||
cfg2_ = cfg.config(confwrite)
|
||||
else:
|
||||
cfg2_ = cfg
|
||||
assert cfg_.value.dict() == make_dict
|
||||
if confread != confwrite:
|
||||
assert(cfg2_.value.dict()) == make_dict
|
||||
_set_value(cfg, pathwrite, confwrite, **kwargs)
|
||||
assert cfg_.value.dict() == make_dict_value
|
||||
if confread != confwrite:
|
||||
assert(cfg2_.value.dict()) == make_dict_value
|
||||
|
||||
|
||||
@autocheck
|
||||
|
|
|
|||
|
|
@ -38,7 +38,7 @@ def test_cache():
|
|||
od1 = make_description()
|
||||
cfg = Config(od1)
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
cfg.option('u1').value.get()
|
||||
assert 'u1' in values.get_cached()
|
||||
assert 'u1' in settings.get_cached()
|
||||
|
|
@ -94,7 +94,7 @@ def test_cache_reset():
|
|||
od1 = make_description()
|
||||
cfg = Config(od1)
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
#when change a value
|
||||
cfg.option('u1').value.get()
|
||||
cfg.option('u2').value.get()
|
||||
|
|
@ -156,7 +156,7 @@ def test_cache_reset_multi():
|
|||
od1 = make_description()
|
||||
cfg = Config(od1)
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
cfg.option('u1').value.get()
|
||||
cfg.option('u3').value.get()
|
||||
assert 'u1' in values.get_cached()
|
||||
|
|
@ -209,7 +209,7 @@ def test_reset_cache():
|
|||
od1 = make_description()
|
||||
cfg = Config(od1)
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
cfg.option('u1').value.get()
|
||||
assert 'u1' in values.get_cached()
|
||||
assert 'u1' in settings.get_cached()
|
||||
|
|
@ -234,7 +234,7 @@ def test_cache_not_cache():
|
|||
od1 = make_description()
|
||||
cfg = Config(od1)
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
cfg.property.remove('cache')
|
||||
cfg.option('u1').value.get()
|
||||
assert 'u1' not in values.get_cached()
|
||||
|
|
@ -250,7 +250,7 @@ def test_cache_leadership():
|
|||
cfg = Config(od1)
|
||||
cfg.property.read_write()
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
assert values.get_cached() == {}
|
||||
#assert settings.get_cached() == {}
|
||||
#
|
||||
|
|
@ -311,7 +311,7 @@ def test_cache_callback():
|
|||
cfg.property.read_write()
|
||||
cfg.value.dict()
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
compare(values.get_cached(), {'val1': {None: ('val', None)},
|
||||
'val2': {None: ('val', None)},
|
||||
'val3': {None: ('yes', None)},
|
||||
|
|
@ -386,11 +386,11 @@ def test_cache_leader_and_followers():
|
|||
#None because no value
|
||||
idx_val2 = None
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
compare(settings.get_cached(), {None: {None: (global_props, None)},
|
||||
'val1': {None: (val1_props, None)},
|
||||
'val1.val1': {None: (val1_val1_props, None)},
|
||||
})
|
||||
'val1.val2': {idx_val2: (val1_val2_props, None)}})
|
||||
# len is 0 so don't get any value
|
||||
compare(values.get_cached(), {'val1.val1': {None: ([], None)}})
|
||||
#
|
||||
|
|
@ -437,11 +437,11 @@ def test_cache_leader_callback():
|
|||
val1_val1_props = frozenset(val1_val1_props)
|
||||
val1_val2_props = frozenset(val1_val2_props)
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
compare(settings.get_cached(), {None: {None: (global_props, None)},
|
||||
'val1': {None: (val1_props, None)},
|
||||
'val1.val1': {None: (val1_val1_props, None)},
|
||||
})
|
||||
'val1.val2': {None: (val1_val2_props, None)}})
|
||||
compare(values.get_cached(), {'val1.val1': {None: ([], None)}})
|
||||
cfg.option('val1.val1').value.set([undefined])
|
||||
compare(settings.get_cached(), {None: {None: (set(global_props), None)},
|
||||
|
|
@ -465,7 +465,7 @@ def test_cache_requires():
|
|||
cfg = Config(od1)
|
||||
cfg.property.read_write()
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
assert values.get_cached() == {}
|
||||
assert cfg.option('ip_address_service').value.get() == None
|
||||
compare(settings.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']), None)},
|
||||
|
|
@ -518,7 +518,7 @@ def test_cache_global_properties():
|
|||
cfg = Config(od1)
|
||||
cfg.property.read_write()
|
||||
values = cfg._config_bag.context._impl_values_cache
|
||||
settings = cfg._config_bag.context.properties_cache
|
||||
settings = cfg._config_bag.context._impl_properties_cache
|
||||
assert values.get_cached() == {}
|
||||
assert cfg.option('ip_address_service').value.get() == None
|
||||
compare(settings.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']), None)},
|
||||
|
|
|
|||
|
|
@ -10,6 +10,7 @@ from .config import config_type, get_config, value_list, global_owner
|
|||
|
||||
import pytest
|
||||
from tiramisu import Config
|
||||
from tiramisu.config import SubConfig
|
||||
from tiramisu.i18n import _
|
||||
from tiramisu import Config, IntOption, FloatOption, ChoiceOption, \
|
||||
BoolOption, StrOption, SymLinkOption, OptionDescription, undefined
|
||||
|
|
|
|||
|
|
@ -82,6 +82,8 @@ def test_make_dict(config_type):
|
|||
cfg.option('s1.a').value.set(True)
|
||||
d = cfg.value.dict()
|
||||
assert d == {"s1.a": True, "int": 43}
|
||||
d2 = cfg.value.dict(flatten=True)
|
||||
assert d2 == {'a': True, 'int': 43}
|
||||
if config_type == 'tiramisu':
|
||||
assert cfg.forcepermissive.value.dict() == {"s1.a": True, "s1.b": False, "int": 43}
|
||||
# assert not list_sessions()
|
||||
|
|
@ -98,7 +100,7 @@ def test_make_dict_sub(config_type):
|
|||
cfg.property.read_write()
|
||||
cfg.permissive.add('hidden')
|
||||
cfg = get_config(cfg, config_type)
|
||||
assert cfg.option('s1').value.dict() == {'s1.a': False}
|
||||
assert cfg.option('s1').value.dict() == {'a': False}
|
||||
|
||||
|
||||
def test_make_dict_not_value(config_type):
|
||||
|
|
@ -167,7 +169,13 @@ def test_make_dict_fullpath(config_type):
|
|||
cfg.property.read_only()
|
||||
cfg = get_config(cfg, config_type)
|
||||
assert cfg.value.dict() == {"opt.s1.a": False, "opt.int": 42, "introot": 42}
|
||||
assert cfg.option('opt').value.dict() == {"opt.s1.a": False, "opt.int": 42}
|
||||
if config_type == 'tiramisu':
|
||||
# FIXME
|
||||
assert cfg.option('opt').value.dict() == {"s1.a": False, "int": 42}
|
||||
assert cfg.value.dict(fullpath=True) == {"opt.s1.a": False, "opt.int": 42, "introot": 42}
|
||||
if config_type == 'tiramisu':
|
||||
# FIXME
|
||||
assert cfg.option('opt').value.dict(fullpath=True) == {"opt.s1.a": False, "opt.int": 42}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ def test_deref_value():
|
|||
b = BoolOption('b', '')
|
||||
o = OptionDescription('od', '', [b])
|
||||
cfg = Config(o)
|
||||
w = weakref.ref(cfg._config_bag.context.get_values())
|
||||
w = weakref.ref(cfg._config_bag.context.cfgimpl_get_values())
|
||||
del cfg
|
||||
assert w() is None
|
||||
|
||||
|
|
@ -26,7 +26,7 @@ def test_deref_setting():
|
|||
b = BoolOption('b', '')
|
||||
o = OptionDescription('od', '', [b])
|
||||
cfg = Config(o)
|
||||
w = weakref.ref(cfg._config_bag.context.get_settings())
|
||||
w = weakref.ref(cfg._config_bag.context.cfgimpl_get_settings())
|
||||
del cfg
|
||||
assert w() is None
|
||||
|
||||
|
|
|
|||
|
|
@ -406,6 +406,7 @@ def test_mandatory_dyndescription():
|
|||
cfg.property.read_only()
|
||||
with pytest.raises(PropertiesOptionError):
|
||||
cfg.option('od.dodval1.stval1').value.get()
|
||||
assert list(cfg.value.mandatory()) == ['od.dodval1.stval1', 'od.dodval2.stval2']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -581,6 +582,7 @@ def test_mandatory_dyndescription_context():
|
|||
cfg.property.read_only()
|
||||
with pytest.raises(PropertiesOptionError):
|
||||
cfg.option('od.dodval1.stval1').value.get()
|
||||
assert list(cfg.value.mandatory()) == ['od.dodval1.stval1', 'od.dodval2.stval2']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -950,6 +952,7 @@ def test_makedict_dyndescription_context():
|
|||
cfg = Config(od2)
|
||||
cfg.option('od.dodval1.stval1').value.set('yes')
|
||||
assert cfg.value.dict() == {'od.val1': ['val1', 'val2'], 'od.dodval1.stval1': 'yes', 'od.dodval2.stval2': None}
|
||||
assert cfg.value.dict(flatten=True) == {'val1': ['val1', 'val2'], 'stval1': 'yes', 'stval2': None}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -1099,14 +1102,14 @@ def test_leadership_dyndescription():
|
|||
cfg = Config(od1)
|
||||
owner = cfg.owner.get()
|
||||
#
|
||||
assert cfg.value.dict() == {'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st2val1': [], 'od.stval2.st1val2.st2val2': [], 'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': []}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == []
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.isdefault()
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').owner.isdefault()
|
||||
#
|
||||
cfg.option('od.stval1.st1val1.st1val1').value.set(['yes'])
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'yes', 'od.stval1.st1val1.st2val1': None}], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st2val1': [None], 'od.stval2.st1val2.st2val2': [], 'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': ['yes']}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == ['yes']
|
||||
assert cfg.option('od.stval1.st1val1.st2val1', 0).value.get() == None
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
|
|
@ -1164,20 +1167,20 @@ def test_leadership_dyndescription_force_store_value_leader():
|
|||
assert cfg.option('od.stval1.st1val1.st2val1', 1).owner.isdefault() == True
|
||||
assert cfg.option('od.stval2.st1val2.st2val2', 0).owner.isdefault() == True
|
||||
assert cfg.option('od.stval2.st1val2.st2val2', 1).owner.isdefault() == True
|
||||
assert cfg.value.dict() == {'od.val1': ['val1', 'val2'], 'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'val1', 'od.stval1.st1val1.st2val1': 'val1'}, {'od.stval1.st1val1.st1val1': 'val2', 'od.stval1.st1val1.st2val1': 'val2'}], 'od.stval2.st1val2.st1val2': [{'od.stval2.st1val2.st1val2': 'val1', 'od.stval2.st1val2.st2val2': 'val1'}, {'od.stval2.st1val2.st1val2': 'val2', 'od.stval2.st1val2.st2val2': 'val2'}]}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': ['val1', 'val2'], 'od.stval1.st1val1.st2val1': ['val1', 'val2'], 'od.stval2.st1val2.st1val2': ['val1', 'val2'], 'od.stval2.st1val2.st2val2': ['val1', 'val2'], 'od.val1': ['val1', 'val2']}
|
||||
#
|
||||
cfg.option('od.val1').value.set(['val1', 'val2', 'val3'])
|
||||
assert cfg.option('od.stval3.st1val3.st1val3').owner.isdefault() == False
|
||||
assert cfg.option('od.stval3.st1val3.st2val3', 0).owner.isdefault() == True
|
||||
assert cfg.option('od.stval3.st1val3.st2val3', 1).owner.isdefault() == True
|
||||
assert cfg.value.dict() == {'od.val1': ['val1', 'val2', 'val3'], 'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'val1', 'od.stval1.st1val1.st2val1': 'val1'}, {'od.stval1.st1val1.st1val1': 'val2', 'od.stval1.st1val1.st2val1': 'val2'}], 'od.stval2.st1val2.st1val2': [{'od.stval2.st1val2.st1val2': 'val1', 'od.stval2.st1val2.st2val2': 'val1'}, {'od.stval2.st1val2.st1val2': 'val2', 'od.stval2.st1val2.st2val2': 'val2'}], 'od.stval3.st1val3.st1val3': [{'od.stval3.st1val3.st1val3': 'val1', 'od.stval3.st1val3.st2val3': 'val1'}, {'od.stval3.st1val3.st1val3': 'val2', 'od.stval3.st1val3.st2val3': 'val2'}]}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': ['val1', 'val2'], 'od.stval1.st1val1.st2val1': ['val1', 'val2'], 'od.stval2.st1val2.st1val2': ['val1', 'val2'], 'od.stval2.st1val2.st2val2': ['val1', 'val2'], 'od.stval3.st1val3.st1val3': ['val1', 'val2'], 'od.stval3.st1val3.st2val3': ['val1', 'val2'], 'od.val1': ['val1', 'val2', 'val3']}
|
||||
#
|
||||
cfg.option('od.stval3.st1val3.st1val3').value.set(['val1', 'val2', 'val3'])
|
||||
assert cfg.option('od.stval3.st1val3.st1val3').owner.isdefault() == False
|
||||
assert cfg.option('od.stval3.st1val3.st2val3', 0).owner.isdefault() == True
|
||||
assert cfg.option('od.stval3.st1val3.st2val3', 1).owner.isdefault() == True
|
||||
assert cfg.option('od.stval3.st1val3.st2val3', 2).owner.isdefault() == True
|
||||
assert cfg.value.dict() == {'od.val1': ['val1', 'val2', 'val3'], 'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'val1', 'od.stval1.st1val1.st2val1': 'val1'}, {'od.stval1.st1val1.st1val1': 'val2', 'od.stval1.st1val1.st2val1': 'val2'}], 'od.stval2.st1val2.st1val2': [{'od.stval2.st1val2.st1val2': 'val1', 'od.stval2.st1val2.st2val2': 'val1'}, {'od.stval2.st1val2.st1val2': 'val2', 'od.stval2.st1val2.st2val2': 'val2'}], 'od.stval3.st1val3.st1val3': [{'od.stval3.st1val3.st1val3': 'val1', 'od.stval3.st1val3.st2val3': 'val1'}, {'od.stval3.st1val3.st1val3': 'val2', 'od.stval3.st1val3.st2val3': 'val2'}, {'od.stval3.st1val3.st1val3': 'val3', 'od.stval3.st1val3.st2val3': 'val3'}]}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': ['val1', 'val2'], 'od.stval1.st1val1.st2val1': ['val1', 'val2'], 'od.stval2.st1val2.st1val2': ['val1', 'val2'], 'od.stval2.st1val2.st2val2': ['val1', 'val2'], 'od.stval3.st1val3.st1val3': ['val1', 'val2', 'val3'], 'od.stval3.st1val3.st2val3': ['val1', 'val2', 'val3'], 'od.val1': ['val1', 'val2', 'val3']}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -1197,20 +1200,20 @@ def test_leadership_dyndescription_force_store_value():
|
|||
assert cfg.option('od.stval1.st1val1.st2val1', 1).owner.isdefault() == False
|
||||
assert cfg.option('od.stval2.st1val2.st2val2', 0).owner.isdefault() == False
|
||||
assert cfg.option('od.stval2.st1val2.st2val2', 1).owner.isdefault() == False
|
||||
assert cfg.value.dict() == {'od.val1': ['val1', 'val2'], 'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'val1', 'od.stval1.st1val1.st2val1': 'val1'}, {'od.stval1.st1val1.st1val1': 'val2', 'od.stval1.st1val1.st2val1': 'val2'}], 'od.stval2.st1val2.st1val2': [{'od.stval2.st1val2.st1val2': 'val1', 'od.stval2.st1val2.st2val2': 'val1'}, {'od.stval2.st1val2.st1val2': 'val2', 'od.stval2.st1val2.st2val2': 'val2'}]}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': ['val1', 'val2'], 'od.stval1.st1val1.st2val1': ['val1', 'val2'], 'od.stval2.st1val2.st1val2': ['val1', 'val2'], 'od.stval2.st1val2.st2val2': ['val1', 'val2'], 'od.val1': ['val1', 'val2']}
|
||||
#
|
||||
cfg.option('od.val1').value.set(['val1', 'val2', 'val3'])
|
||||
assert cfg.option('od.stval3.st1val3.st1val3').owner.isdefault() == True
|
||||
assert cfg.option('od.stval3.st1val3.st2val3', 0).owner.isdefault() == False
|
||||
assert cfg.option('od.stval3.st1val3.st2val3', 1).owner.isdefault() == False
|
||||
assert cfg.value.dict() == {'od.val1': ['val1', 'val2', 'val3'], 'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'val1', 'od.stval1.st1val1.st2val1': 'val1'}, {'od.stval1.st1val1.st1val1': 'val2', 'od.stval1.st1val1.st2val1': 'val2'}], 'od.stval2.st1val2.st1val2': [{'od.stval2.st1val2.st1val2': 'val1', 'od.stval2.st1val2.st2val2': 'val1'}, {'od.stval2.st1val2.st1val2': 'val2', 'od.stval2.st1val2.st2val2': 'val2'}], 'od.stval3.st1val3.st1val3': [{'od.stval3.st1val3.st1val3': 'val1', 'od.stval3.st1val3.st2val3': 'val1'}, {'od.stval3.st1val3.st1val3': 'val2', 'od.stval3.st1val3.st2val3': 'val2'}]}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': ['val1', 'val2'], 'od.stval1.st1val1.st2val1': ['val1', 'val2'], 'od.stval2.st1val2.st1val2': ['val1', 'val2'], 'od.stval2.st1val2.st2val2': ['val1', 'val2'], 'od.stval3.st1val3.st1val3': ['val1', 'val2'], 'od.stval3.st1val3.st2val3': ['val1', 'val2'], 'od.val1': ['val1', 'val2', 'val3']}
|
||||
#
|
||||
cfg.option('od.stval3.st1val3.st1val3').value.set(['val1', 'val2', 'val3'])
|
||||
assert cfg.option('od.stval3.st1val3.st1val3').owner.isdefault() == False
|
||||
assert cfg.option('od.stval3.st1val3.st2val3', 0).owner.isdefault() == False
|
||||
assert cfg.option('od.stval3.st1val3.st2val3', 1).owner.isdefault() == False
|
||||
assert cfg.option('od.stval3.st1val3.st2val3', 2).owner.isdefault() == False
|
||||
assert cfg.value.dict() == {'od.val1': ['val1', 'val2', 'val3'], 'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'val1', 'od.stval1.st1val1.st2val1': 'val1'}, {'od.stval1.st1val1.st1val1': 'val2', 'od.stval1.st1val1.st2val1': 'val2'}], 'od.stval2.st1val2.st1val2': [{'od.stval2.st1val2.st1val2': 'val1', 'od.stval2.st1val2.st2val2': 'val1'}, {'od.stval2.st1val2.st1val2': 'val2', 'od.stval2.st1val2.st2val2': 'val2'}], 'od.stval3.st1val3.st1val3': [{'od.stval3.st1val3.st1val3': 'val1', 'od.stval3.st1val3.st2val3': 'val1'}, {'od.stval3.st1val3.st1val3': 'val2', 'od.stval3.st1val3.st2val3': 'val2'}, {'od.stval3.st1val3.st1val3': 'val3', 'od.stval3.st1val3.st2val3': 'val3'}]}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': ['val1', 'val2'], 'od.stval1.st1val1.st2val1': ['val1', 'val2'], 'od.stval2.st1val2.st1val2': ['val1', 'val2'], 'od.stval2.st1val2.st2val2': ['val1', 'val2'], 'od.stval3.st1val3.st1val3': ['val1', 'val2', 'val3'], 'od.stval3.st1val3.st2val3': ['val1', 'val2', 'val3'], 'od.val1': ['val1', 'val2', 'val3']}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -1250,14 +1253,14 @@ def test_leadership_dyndescription_param():
|
|||
od1 = OptionDescription('od', '', [od])
|
||||
cfg = Config(od1)
|
||||
owner = cfg.owner.get()
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [], 'od.stval2.st1val2.st1val2': [], 'od.odval1.val1': ['val1', 'val2']}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st2val1': [], 'od.stval2.st1val2.st2val2': [], 'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': [], 'od.odval1.val1': ['val1', 'val2']}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == []
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.get() == owners.default
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').owner.get() == owners.default
|
||||
#
|
||||
cfg.option('od.stval1.st1val1.st1val1').value.set(['yes'])
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'yes', 'od.stval1.st1val1.st2val1': None}], 'od.stval2.st1val2.st1val2': [], 'od.odval1.val1': ['val1', 'val2']}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st2val1': [None], 'od.stval2.st1val2.st2val2': [], 'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': ['yes'], 'od.odval1.val1': ['val1', 'val2']}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == ['yes']
|
||||
assert cfg.option('od.stval1.st1val1.st2val1', 0).value.get() == None
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
|
|
@ -1330,14 +1333,14 @@ def _test_leadership(cfg):
|
|||
cfg.option('od.val1.val1').value.set(['val1', 'val2'])
|
||||
cfg.option('od.val1.val2', 0).value.set('val1')
|
||||
cfg.option('od.val1.val2', 1).value.set('val2')
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [], 'od.stval2.st1val2.st1val2': [], 'od.val1.val1': [{'od.val1.val1': 'val1', 'od.val1.val2': 'val1'}, {'od.val1.val1': 'val2', 'od.val1.val2': 'val2'}]}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st2val1': [], 'od.stval2.st1val2.st2val2': [], 'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': [], 'od.val1.val1': ['val1', 'val2'], 'od.val1.val2': ['val1', 'val2']}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == []
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.get() == owners.default
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').owner.get() == owners.default
|
||||
#
|
||||
cfg.option('od.stval1.st1val1.st1val1').value.set(['yes'])
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'yes', 'od.stval1.st1val1.st2val1': None}], 'od.stval2.st1val2.st1val2': [], 'od.val1.val1': [{'od.val1.val1': 'val1', 'od.val1.val2': 'val1'}, {'od.val1.val1': 'val2', 'od.val1.val2': 'val2'}]}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st2val1': [None], 'od.stval2.st1val2.st2val2': [], 'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': ['yes'], 'od.val1.val1': ['val1', 'val2'], 'od.val1.val2': ['val1', 'val2']}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == ['yes']
|
||||
assert cfg.option('od.stval1.st1val1.st2val1', 0).value.get() == None
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
|
|
@ -1501,14 +1504,14 @@ def test_leadership_callback_dyndescription():
|
|||
od2 = OptionDescription('od', '', [od1])
|
||||
cfg = Config(od2)
|
||||
owner = cfg.owner.get()
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st2val1': [], 'od.stval2.st1val2.st2val2': [], 'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': []}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() ==[]
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.isdefault()
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').owner.isdefault()
|
||||
#
|
||||
cfg.option('od.stval1.st1val1.st1val1').value.set(['yes'])
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'yes', 'od.stval1.st1val1.st2val1': 'yes'}], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st2val1': ['yes'], 'od.stval2.st1val2.st2val2': [], 'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': ['yes']}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == ['yes']
|
||||
assert cfg.option('od.stval1.st1val1.st2val1', 0).value.get() == 'yes'
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
|
|
@ -1596,21 +1599,36 @@ def test_leadership_callback_samegroup_dyndescription():
|
|||
od2 = OptionDescription('od', '', [od1])
|
||||
cfg = Config(od2)
|
||||
owner = cfg.owner.get()
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [],
|
||||
'od.stval1.st1val1.st2val1': [],
|
||||
'od.stval1.st1val1.st3val1': [],
|
||||
'od.stval2.st1val2.st1val2': [],
|
||||
'od.stval2.st1val2.st2val2': [],
|
||||
'od.stval2.st1val2.st3val2': []}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == []
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.isdefault()
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').owner.isdefault()
|
||||
#
|
||||
cfg.option('od.stval1.st1val1.st1val1').value.set(['yes'])
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'yes', 'od.stval1.st1val1.st2val1': None, 'od.stval1.st1val1.st3val1': None}], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': ['yes'],
|
||||
'od.stval1.st1val1.st2val1': [None],
|
||||
'od.stval1.st1val1.st3val1': [None],
|
||||
'od.stval2.st1val2.st1val2': [],
|
||||
'od.stval2.st1val2.st2val2': [],
|
||||
'od.stval2.st1val2.st3val2': []}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.get() == owner
|
||||
assert cfg.option('od.stval1.st1val1.st2val1', 0).owner.isdefault()
|
||||
assert cfg.option('od.stval1.st1val1.st3val1', 0).owner.isdefault()
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').owner.isdefault()
|
||||
#
|
||||
cfg.option('od.stval1.st1val1.st2val1', 0).value.set('yes')
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'yes', 'od.stval1.st1val1.st2val1': 'yes', 'od.stval1.st1val1.st3val1': 'yes'}], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': ['yes'],
|
||||
'od.stval1.st1val1.st2val1': ['yes'],
|
||||
'od.stval1.st1val1.st3val1': ['yes'],
|
||||
'od.stval2.st1val2.st1val2': [],
|
||||
'od.stval2.st1val2.st2val2': [],
|
||||
'od.stval2.st1val2.st3val2': []}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.get() == owner
|
||||
assert cfg.option('od.stval1.st1val1.st2val1', 0).owner.get() == owner
|
||||
assert cfg.option('od.stval1.st1val1.st3val1', 0).owner.isdefault()
|
||||
|
|
@ -1694,14 +1712,14 @@ def test_leadership_dyndescription_convert():
|
|||
cfg = Config(od1)
|
||||
owner = cfg.owner.get()
|
||||
#
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st2val1': [], 'od.stval2.st1val2.st2val2': [], 'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': []}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == []
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.isdefault()
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').owner.isdefault()
|
||||
#
|
||||
cfg.option('od.stval1.st1val1.st1val1').value.set(['yes'])
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'yes', 'od.stval1.st1val1.st2val1': None}], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st2val1': [None], 'od.stval2.st1val2.st2val2': [], 'od.stval2.st1val2.st1val2': [], 'od.stval1.st1val1.st1val1': ['yes']}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == ['yes']
|
||||
assert cfg.option('od.stval1.st1val1.st2val1', 0).value.get() == None
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
|
|
@ -1753,21 +1771,36 @@ def test_leadership_callback_samegroup_dyndescription_convert():
|
|||
od2 = OptionDescription('od', '', [od1])
|
||||
cfg = Config(od2)
|
||||
owner = cfg.owner.get()
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [],
|
||||
'od.stval1.st1val1.st2val1': [],
|
||||
'od.stval1.st1val1.st3val1': [],
|
||||
'od.stval2.st1val2.st1val2': [],
|
||||
'od.stval2.st1val2.st2val2': [],
|
||||
'od.stval2.st1val2.st3val2': []}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').value.get() == []
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').value.get() == []
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.isdefault()
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').owner.isdefault()
|
||||
#
|
||||
cfg.option('od.stval1.st1val1.st1val1').value.set(['yes'])
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'yes', 'od.stval1.st1val1.st2val1': None, 'od.stval1.st1val1.st3val1': None}], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': ['yes'],
|
||||
'od.stval1.st1val1.st2val1': [None],
|
||||
'od.stval1.st1val1.st3val1': [None],
|
||||
'od.stval2.st1val2.st1val2': [],
|
||||
'od.stval2.st1val2.st2val2': [],
|
||||
'od.stval2.st1val2.st3val2': []}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.get() == owner
|
||||
assert cfg.option('od.stval1.st1val1.st2val1', 0).owner.isdefault()
|
||||
assert cfg.option('od.stval1.st1val1.st3val1', 0).owner.isdefault()
|
||||
assert cfg.option('od.stval2.st1val2.st1val2').owner.isdefault()
|
||||
#
|
||||
cfg.option('od.stval1.st1val1.st2val1', 0).value.set('yes')
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': [{'od.stval1.st1val1.st1val1': 'yes', 'od.stval1.st1val1.st2val1': 'yes', 'od.stval1.st1val1.st3val1': 'yes'}], 'od.stval2.st1val2.st1val2': []}
|
||||
assert cfg.value.dict() == {'od.stval1.st1val1.st1val1': ['yes'],
|
||||
'od.stval1.st1val1.st2val1': ['yes'],
|
||||
'od.stval1.st1val1.st3val1': ['yes'],
|
||||
'od.stval2.st1val2.st1val2': [],
|
||||
'od.stval2.st1val2.st2val2': [],
|
||||
'od.stval2.st1val2.st3val2': []}
|
||||
assert cfg.option('od.stval1.st1val1.st1val1').owner.get() == owner
|
||||
assert cfg.option('od.stval1.st1val1.st2val1', 0).owner.get() == owner
|
||||
assert cfg.option('od.stval1.st1val1.st3val1', 0).owner.isdefault()
|
||||
|
|
@ -1791,7 +1824,7 @@ def test_dyn_with_leader_hidden_in_config():
|
|||
cfg.option('leaderval1.ip_admin_eth0val1.ip_admin_eth0val1').value.get()
|
||||
with pytest.raises(PropertiesOptionError):
|
||||
cfg.option('leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1', 0).value.get()
|
||||
cfg.value.dict() == {'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': [{'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': '192.168.1.1'}],
|
||||
cfg.value.dict(leader_to_list=True) == {'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': [{'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': '192.168.1.1'}],
|
||||
'leaderval2.ip_admin_eth0val2.ip_admin_eth0val2': [{'leaderval2.ip_admin_eth0val2.ip_admin_eth0val2': '192.168.1.1'}]}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
|
@ -1825,7 +1858,12 @@ def test_dyn_leadership_requires():
|
|||
assert cfg.option('leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1', 1).value.get() is None
|
||||
cfg.option('leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1', 1).value.set('255.255.255.255')
|
||||
assert cfg.option('leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1', 1).value.get() == '255.255.255.255'
|
||||
ret = cfg.value.dict()
|
||||
assert cfg.value.dict() == {'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': ['192.168.1.2', '192.168.1.2'],
|
||||
'leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1': [None, '255.255.255.255'],
|
||||
'leaderval2.ip_admin_eth0val2.ip_admin_eth0val2': [],
|
||||
'leaderval2.ip_admin_eth0val2.netmask_admin_eth0val2': []}
|
||||
|
||||
ret = cfg.value.dict(leader_to_list=True)
|
||||
assert ret == {'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': [{'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': '192.168.1.2', 'leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1': None},
|
||||
{'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': '192.168.1.2', 'leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1': '255.255.255.255'}],
|
||||
'leaderval2.ip_admin_eth0val2.ip_admin_eth0val2': []}
|
||||
|
|
@ -1835,8 +1873,24 @@ def test_dyn_leadership_requires():
|
|||
assert cfg.option('leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1', 0).value.get() is None
|
||||
with pytest.raises(PropertiesOptionError):
|
||||
cfg.option('leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1', 1).value.get()
|
||||
assert cfg.value.dict() == {'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': [{'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': '192.168.1.2', 'leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1': None}, {'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': '192.168.1.1'}], 'leaderval2.ip_admin_eth0val2.ip_admin_eth0val2': []}
|
||||
ret = cfg.value.dict()
|
||||
assert set(ret.keys()) == set(['leaderval1.ip_admin_eth0val1.ip_admin_eth0val1', 'leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1', 'leaderval2.ip_admin_eth0val2.ip_admin_eth0val2', 'leaderval2.ip_admin_eth0val2.netmask_admin_eth0val2'])
|
||||
assert ret['leaderval1.ip_admin_eth0val1.ip_admin_eth0val1'] == ['192.168.1.2', '192.168.1.1']
|
||||
assert len(ret['leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1']) == 2
|
||||
assert ret['leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1'][0] is None
|
||||
assert isinstance(ret['leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1'][1], PropertiesOptionError)
|
||||
del ret['leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1'][1]
|
||||
del ret['leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1'][0]
|
||||
del ret['leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1']
|
||||
assert cfg.value.dict(leader_to_list=True) == {'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': [{'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': '192.168.1.2',
|
||||
'leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1': None},
|
||||
{'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': '192.168.1.1'}],
|
||||
'leaderval2.ip_admin_eth0val2.ip_admin_eth0val2': []}
|
||||
#
|
||||
assert cfg.value.dict(leader_to_list=True) == {'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': [{'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': '192.168.1.2',
|
||||
'leaderval1.ip_admin_eth0val1.netmask_admin_eth0val1': None},
|
||||
{'leaderval1.ip_admin_eth0val1.ip_admin_eth0val1': '192.168.1.1'}],
|
||||
'leaderval2.ip_admin_eth0val2.ip_admin_eth0val2': []}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -62,7 +62,17 @@ def test_base_config(config_type):
|
|||
if config_type != 'tiramisu-api':
|
||||
ret = cfg.option.find('nom_machine', first=True)
|
||||
assert ret.value.get() == "eoleng"
|
||||
assert cfg.option('creole').value.dict() == {'creole.general.numero_etab': None, 'creole.general.nom_machine': 'eoleng', 'creole.general.nombre_interfaces': 1, 'creole.general.activer_proxy_client': False, 'creole.general.mode_conteneur_actif': False, 'creole.general.serveur_ntp': [], 'creole.general.time_zone': 'Paris', 'creole.interface1.ip_admin_eth0.ip_admin_eth0': None, 'creole.interface1.ip_admin_eth0.netmask_admin_eth0': None}
|
||||
result = {'general.numero_etab': None, 'general.nombre_interfaces': 1,
|
||||
'general.serveur_ntp': [], 'interface1.ip_admin_eth0.ip_admin_eth0': None,
|
||||
'general.mode_conteneur_actif': False, 'general.time_zone': 'Paris',
|
||||
'interface1.ip_admin_eth0.netmask_admin_eth0': None, 'general.nom_machine':
|
||||
'eoleng', 'general.activer_proxy_client': False}
|
||||
assert cfg.option('creole').value.dict() == result
|
||||
result = {'serveur_ntp': [], 'mode_conteneur_actif': False,
|
||||
'ip_admin_eth0': None, 'time_zone': 'Paris', 'numero_etab': None,
|
||||
'netmask_admin_eth0': None, 'nom_machine': 'eoleng', 'activer_proxy_client':
|
||||
False, 'nombre_interfaces': 1}
|
||||
assert cfg.option('creole').value.dict(flatten=True) == result
|
||||
if config_type == 'tiramisu-api':
|
||||
cfg.send()
|
||||
# assert not list_sessions()
|
||||
|
|
@ -84,13 +94,11 @@ def test_iter_on_groups():
|
|||
cfg = Config(od1)
|
||||
cfg.property.read_write()
|
||||
result = cfg.option('creole').list('optiondescription',
|
||||
group_type=groups.family,
|
||||
)
|
||||
group_type=groups.family)
|
||||
group_names = [res.option.name() for res in result]
|
||||
assert group_names == ['general', 'interface1']
|
||||
for i in cfg.option('creole').list('optiondescription',
|
||||
group_type=groups.family,
|
||||
):
|
||||
group_type=groups.family):
|
||||
#test StopIteration
|
||||
break
|
||||
result = cfg.option('creole').list('option',
|
||||
|
|
@ -117,7 +125,7 @@ def test_list_recursive():
|
|||
'netmask_admin_eth0']
|
||||
result = list(cfg.option.list(recursive=True, type='optiondescription'))
|
||||
group_names = [res.option.name() for res in result]
|
||||
assert group_names == ['creole', 'general', 'interface1', 'ip_admin_eth0']
|
||||
assert group_names == ['general', 'ip_admin_eth0', 'interface1', 'creole']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -177,8 +185,12 @@ def test_iter_not_group():
|
|||
od1 = OptionDescription("name", "descr", [])
|
||||
cfg = Config(od1)
|
||||
cfg.property.read_write()
|
||||
with pytest.raises(AssertionError):
|
||||
print(list(cfg.option.list(type='optiondescription', group_type='family')))
|
||||
try:
|
||||
list(cfg.option.list(type='optiondescription', group_type='family'))
|
||||
except AssertionError:
|
||||
pass
|
||||
else:
|
||||
raise Exception('must raise')
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -245,7 +257,8 @@ def test_groups_with_leader_make_dict(config_type):
|
|||
od1 = OptionDescription('root', '', [interface1])
|
||||
cfg = Config(od1)
|
||||
cfg = get_config(cfg, config_type)
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': []}
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': []}
|
||||
assert cfg.value.dict(leader_to_list=True) == {'ip_admin_eth0.ip_admin_eth0': []}
|
||||
if config_type != 'tiramisu-api':
|
||||
# FIXME useful? already in leadership
|
||||
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.len() == 0
|
||||
|
|
@ -255,7 +268,8 @@ def test_groups_with_leader_make_dict(config_type):
|
|||
# FIXME
|
||||
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.len() == 2
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0').value.len() == 2
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': 'ip1', 'ip_admin_eth0.netmask_admin_eth0': None}, {'ip_admin_eth0.ip_admin_eth0': 'ip2', 'ip_admin_eth0.netmask_admin_eth0': None}]}
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['ip1', 'ip2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None]}
|
||||
assert cfg.value.dict(leader_to_list=True) == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': 'ip1', 'ip_admin_eth0.netmask_admin_eth0': None}, {'ip_admin_eth0.ip_admin_eth0': 'ip2', 'ip_admin_eth0.netmask_admin_eth0': None}]}
|
||||
if config_type == 'tiramisu-api':
|
||||
cfg.send()
|
||||
# assert not list_sessions()
|
||||
|
|
@ -278,7 +292,8 @@ def test_groups_with_leader_make_dict2(config_type):
|
|||
od1 = OptionDescription('root', '', [interface1])
|
||||
cfg = Config(od1)
|
||||
cfg = get_config(cfg, config_type)
|
||||
assert cfg.value.dict() == {'other.ip_admin_eth0': []}
|
||||
assert cfg.value.dict() == {'other.ip_admin_eth0': [], 'other.netmask_admin_eth0': []}
|
||||
assert cfg.value.dict(leader_to_list=True) == {'other.ip_admin_eth0': []}
|
||||
if config_type != 'tiramisu-api':
|
||||
# FIXME useful? already in leadership
|
||||
assert cfg.option('other.ip_admin_eth0').value.len() == 0
|
||||
|
|
@ -288,7 +303,8 @@ def test_groups_with_leader_make_dict2(config_type):
|
|||
# FIXME
|
||||
assert cfg.option('other.ip_admin_eth0').value.len() == 2
|
||||
assert cfg.option('other.netmask_admin_eth0').value.len() == 2
|
||||
assert cfg.value.dict() == {'other.ip_admin_eth0': [{'other.ip_admin_eth0': 'ip1', 'other.netmask_admin_eth0': None}, {'other.ip_admin_eth0': 'ip2', 'other.netmask_admin_eth0': None}]}
|
||||
assert cfg.value.dict() == {'other.ip_admin_eth0': ['ip1', 'ip2'], 'other.netmask_admin_eth0': [None, None]}
|
||||
assert cfg.value.dict(leader_to_list=True) == {'other.ip_admin_eth0': [{'other.ip_admin_eth0': 'ip1', 'other.netmask_admin_eth0': None}, {'other.ip_admin_eth0': 'ip2', 'other.netmask_admin_eth0': None}]}
|
||||
if config_type == 'tiramisu-api':
|
||||
cfg.send()
|
||||
# assert not list_sessions()
|
||||
|
|
@ -328,11 +344,13 @@ def test_groups_with_leader_default_value_2(config_type):
|
|||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == 'netmask1'
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.default() == 'netmask1'
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.default() == 'netmask1'
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0').value.default() == ['netmask1', 'netmask1']
|
||||
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('netmask2')
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == 'netmask1'
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == 'netmask2'
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.default() == 'netmask1'
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.default() == 'netmask1'
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0').value.default() == ['netmask1', 'netmask1']
|
||||
if config_type == 'tiramisu-api':
|
||||
cfg.send()
|
||||
# assert not list_sessions()
|
||||
|
|
@ -354,6 +372,7 @@ def test_groups_with_leader_hidden_in_config():
|
|||
with pytest.raises(PropertiesOptionError):
|
||||
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
|
||||
assert cfg.value.dict() == {}
|
||||
assert cfg.value.dict(leader_to_list=True) == {}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -5,9 +5,9 @@ do_autopath()
|
|||
|
||||
import pytest
|
||||
from tiramisu import Config
|
||||
from tiramisu import IntOption, StrOption, OptionDescription, DynOptionDescription, \
|
||||
from tiramisu import IntOption, StrOption, OptionDescription, \
|
||||
SymLinkOption, Leadership, undefined, Calculation, Params, \
|
||||
ParamOption, ParamValue, ParamIndex, calc_value
|
||||
ParamOption, ParamValue, calc_value
|
||||
from tiramisu.error import PropertiesOptionError, ConfigError
|
||||
from tiramisu.setting import groups
|
||||
|
||||
|
|
@ -36,14 +36,14 @@ def return_value(value):
|
|||
|
||||
|
||||
def make_description2():
|
||||
stroption = StrOption('str', 'str', default="abc",
|
||||
stroption = StrOption('str', 'Test string option', default="abc",
|
||||
properties=('mandatory', ))
|
||||
stroption1 = StrOption('str1', 'str1',
|
||||
stroption1 = StrOption('str1', 'Test string option',
|
||||
properties=('mandatory', ))
|
||||
stroption2 = SymLinkOption('unicode2', stroption1)
|
||||
stroption3 = StrOption('str3', 'str3', multi=True,
|
||||
stroption3 = StrOption('str3', 'Test string option', multi=True,
|
||||
properties=('mandatory', ))
|
||||
unicode1 = StrOption('unicode1', 'unicode1', Calculation(return_value, Params(ParamOption(stroption))), properties=('mandatory',))
|
||||
unicode1 = StrOption('unicode1', 'Test string option', Calculation(return_value, Params(ParamOption(stroption))), properties=('mandatory',))
|
||||
descr = OptionDescription('tiram', '', [stroption, stroption1, stroption2, stroption3, unicode1])
|
||||
return descr
|
||||
|
||||
|
|
@ -319,18 +319,6 @@ def test_mandatory_unicode():
|
|||
# assert not list_sessions()
|
||||
|
||||
|
||||
def compare(ret, expected):
|
||||
assert(len(ret) == len(expected))
|
||||
for index, opt in enumerate(ret):
|
||||
exp = expected[index]
|
||||
if isinstance(exp, list):
|
||||
assert opt.option.path() == exp[0]
|
||||
assert opt.option.index() == exp[1]
|
||||
else:
|
||||
assert opt.option.path() == exp
|
||||
assert opt.option.index() == None
|
||||
|
||||
|
||||
def test_mandatory_warnings_ro():
|
||||
od1 = make_description()
|
||||
cfg = Config(od1)
|
||||
|
|
@ -342,11 +330,11 @@ def test_mandatory_warnings_ro():
|
|||
except PropertiesOptionError as err:
|
||||
prop = err.proptype
|
||||
assert 'mandatory' in prop
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'unicode2', 'str3'])
|
||||
assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2', 'str3']
|
||||
cfg.property.read_write()
|
||||
cfg.option('str').value.set('a')
|
||||
cfg.property.read_only()
|
||||
compare(cfg.value.mandatory(), ['str1', 'unicode2', 'str3'])
|
||||
assert list(cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -356,9 +344,9 @@ def test_mandatory_warnings_rw():
|
|||
cfg.option('str').value.set('')
|
||||
cfg.property.read_write()
|
||||
cfg.option('str').value.get()
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'unicode2', 'str3'])
|
||||
assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2', 'str3']
|
||||
cfg.option('str').value.set('a')
|
||||
compare(cfg.value.mandatory(), ['str1', 'unicode2', 'str3'])
|
||||
assert list(cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -368,9 +356,9 @@ def test_mandatory_warnings_disabled():
|
|||
cfg.option('str').value.set('')
|
||||
cfg.property.read_write()
|
||||
cfg.option('str').value.get()
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'unicode2', 'str3'])
|
||||
assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
|
||||
cfg.option('str').property.add('disabled')
|
||||
compare(cfg.value.mandatory(), ['str1', 'unicode2', 'str3'])
|
||||
assert set(cfg.value.mandatory()) == {'str1', 'unicode2', 'str3'}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -381,9 +369,9 @@ def test_mandatory_warnings_hidden():
|
|||
cfg.property.read_write()
|
||||
cfg.permissive.add('hidden')
|
||||
cfg.option('str').value.get()
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'unicode2', 'str3'])
|
||||
assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
|
||||
cfg.option('str').property.add('hidden')
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'unicode2', 'str3'])
|
||||
assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -393,10 +381,10 @@ def test_mandatory_warnings_frozen():
|
|||
cfg.option('str').value.set('')
|
||||
cfg.property.read_write()
|
||||
cfg.option('str').value.get()
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'unicode2', 'str3'])
|
||||
assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
|
||||
cfg.option('str').property.add('frozen')
|
||||
cfg.property.read_only()
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'unicode2', 'str3'])
|
||||
assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -441,7 +429,7 @@ def test_mandatory_warnings_leader():
|
|||
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
|
||||
od1 = OptionDescription('o', '', [interface1])
|
||||
cfg = Config(od1)
|
||||
compare(cfg.value.mandatory(), ['ip_admin_eth0.ip_admin_eth0'])
|
||||
assert list(cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -504,17 +492,17 @@ def test_mandatory_warnings_leader_empty():
|
|||
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([undefined])
|
||||
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [None]
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
|
||||
compare(cfg.value.mandatory(), ['ip_admin_eth0.ip_admin_eth0'])
|
||||
assert list(cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
|
||||
cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
|
||||
#
|
||||
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([''])
|
||||
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['']
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
|
||||
compare(cfg.value.mandatory(), ['ip_admin_eth0.ip_admin_eth0'])
|
||||
assert list(cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
|
||||
#
|
||||
cfg.property.read_write()
|
||||
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
|
||||
compare(cfg.value.mandatory(), [])
|
||||
assert list(cfg.value.mandatory()) == []
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -527,7 +515,8 @@ def test_mandatory_follower():
|
|||
cfg = Config(od1)
|
||||
cfg.property.read_only()
|
||||
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': []}
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [],
|
||||
'ip_admin_eth0.netmask_admin_eth0': []}
|
||||
#
|
||||
cfg.property.read_write()
|
||||
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
|
||||
|
|
@ -548,7 +537,8 @@ def test_mandatory_follower():
|
|||
cfg.property.read_only()
|
||||
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == 'ip'
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': 'ip', 'ip_admin_eth0.netmask_admin_eth0': 'ip'}]}
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['ip'],
|
||||
'ip_admin_eth0.netmask_admin_eth0': ['ip']}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -563,9 +553,9 @@ def test_mandatory_warnings_follower():
|
|||
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
||||
#
|
||||
cfg.property.read_write()
|
||||
compare(cfg.value.mandatory(), [])
|
||||
assert list(cfg.value.mandatory()) == []
|
||||
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
|
||||
compare(cfg.value.mandatory(), [['ip_admin_eth0.netmask_admin_eth0', 0]])
|
||||
assert list(cfg.value.mandatory()) == ['ip_admin_eth0.netmask_admin_eth0']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -575,10 +565,10 @@ def test_mandatory_warnings_symlink():
|
|||
cfg.option('str').value.set('')
|
||||
cfg.property.read_write()
|
||||
cfg.option('str').value.get()
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'str3'])
|
||||
assert list(cfg.value.mandatory()) == ['str', 'str1', 'str3']
|
||||
cfg.option('str').property.add('frozen')
|
||||
cfg.property.read_only()
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'str3'])
|
||||
assert list(cfg.value.mandatory()) == ['str', 'str1', 'str3']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -587,7 +577,7 @@ def test_mandatory_warnings_validate_empty():
|
|||
cfg = Config(od1)
|
||||
cfg.option('str').value.set('')
|
||||
cfg.property.read_only()
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'str3', 'unicode1'])
|
||||
assert list(cfg.value.mandatory()) == ['str', 'str1', 'str3']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -609,12 +599,12 @@ def test_mandatory_warnings_requires():
|
|||
cfg.option('str').value.set('')
|
||||
cfg.property.read_write()
|
||||
cfg.option('str').value.get()
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'unicode2'])
|
||||
assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2']
|
||||
cfg.property.read_only()
|
||||
compare(cfg.value.mandatory(), ['str', 'str1', 'unicode2'])
|
||||
assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2']
|
||||
cfg.property.read_write()
|
||||
cfg.option('str').value.set('yes')
|
||||
compare(cfg.value.mandatory(), ['str1', 'unicode2', 'str3'])
|
||||
assert list(cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -634,9 +624,9 @@ def test_mandatory_warnings_requires_leadership():
|
|||
cfg = Config(od1)
|
||||
cfg.option('str').value.set('')
|
||||
cfg.option('leader.str1').value.set(['str'])
|
||||
compare(cfg.value.mandatory(), ['str'])
|
||||
assert list(cfg.value.mandatory()) == ['str']
|
||||
cfg.option('str').value.set('yes')
|
||||
compare(cfg.value.mandatory(), [['leader.str2', 0]])
|
||||
assert list(cfg.value.mandatory()) == ['leader.str2']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -654,21 +644,9 @@ def test_mandatory_warnings_requires_leadership_follower():
|
|||
od1 = OptionDescription('tiram', '', [leadership])
|
||||
cfg = Config(od1)
|
||||
cfg.option('leader.str').value.set(['str'])
|
||||
compare(cfg.value.mandatory(), [])
|
||||
assert list(cfg.value.mandatory()) == []
|
||||
cfg.option('leader.str1', 0).value.set('yes')
|
||||
compare(cfg.value.mandatory(), [['leader.str2', 0]])
|
||||
cfg.option('leader.str2', 0).value.set('yes')
|
||||
compare(cfg.value.mandatory(), [])
|
||||
#
|
||||
cfg.option('leader.str').value.set(['str', 'str1'])
|
||||
compare(cfg.value.mandatory(), [])
|
||||
cfg.option('leader.str1', 1).value.set('yes')
|
||||
compare(cfg.value.mandatory(), [['leader.str2', 1]])
|
||||
cfg.option('leader.str2', 1).value.set('yes')
|
||||
compare(cfg.value.mandatory(), [])
|
||||
cfg.option('leader.str2', 0).value.reset()
|
||||
cfg.option('leader.str2', 1).value.reset()
|
||||
compare(cfg.value.mandatory(), [['leader.str2', 0], ['leader.str2', 1]])
|
||||
assert list(cfg.value.mandatory()) == ['leader.str2']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -677,49 +655,7 @@ def test_mandatory_od_disabled():
|
|||
od1 = OptionDescription('od', '', [descr])
|
||||
cfg = Config(od1)
|
||||
cfg.property.read_only()
|
||||
compare(cfg.value.mandatory(), ['tiram.str1', 'tiram.unicode2', 'tiram.str3'])
|
||||
assert list(cfg.value.mandatory()) == ['tiram.str1', 'tiram.unicode2', 'tiram.str3']
|
||||
cfg.option('tiram').property.add('disabled')
|
||||
compare(cfg.value.mandatory(), [])
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
def return_list(val=None, suffix=None):
|
||||
if val:
|
||||
return val
|
||||
else:
|
||||
return ['val1', 'val2']
|
||||
|
||||
|
||||
def test_mandatory_dyndescription():
|
||||
st = StrOption('st', '', properties=('mandatory',))
|
||||
dod = DynOptionDescription('dod', '', [st], suffixes=Calculation(return_list))
|
||||
od = OptionDescription('od', '', [dod])
|
||||
od2 = OptionDescription('od', '', [od])
|
||||
cfg = Config(od2)
|
||||
cfg.property.read_only()
|
||||
compare(cfg.value.mandatory(), ['od.dodval1.stval1', 'od.dodval2.stval2'])
|
||||
|
||||
|
||||
def test_mandatory_dyndescription_context():
|
||||
val1 = StrOption('val1', '', ['val1', 'val2'], multi=True)
|
||||
st = StrOption('st', '', properties=('mandatory',))
|
||||
dod = DynOptionDescription('dod', '', [st], suffixes=Calculation(return_list, Params(ParamOption(val1))))
|
||||
od = OptionDescription('od', '', [dod, val1])
|
||||
od2 = OptionDescription('od', '', [od])
|
||||
cfg = Config(od2)
|
||||
cfg.property.read_only()
|
||||
compare(cfg.value.mandatory(), ['od.dodval1.stval1', 'od.dodval2.stval2'])
|
||||
|
||||
|
||||
def test_mandatory_callback_leader_and_followers_leader():
|
||||
val1 = StrOption('val1', "", multi=True, properties=('mandatory', 'empty'))
|
||||
val2 = StrOption('val2', "", multi=True, default_multi='val2', properties=('expert',))
|
||||
val3 = StrOption('val3', "", Calculation(calc_value, Params(ParamOption(val2), {'index': ParamIndex()})), multi=True)
|
||||
val4 = StrOption('val4', "", Calculation(calc_value, Params(ParamOption(val3), {'index': ParamIndex()})), multi=True)
|
||||
interface1 = Leadership('val1', '', [val1, val2, val3, val4])
|
||||
od1 = OptionDescription('rootconfig', '', [interface1])
|
||||
cfg = Config(od1)
|
||||
cfg.property.read_write()
|
||||
# FIXME cfg = get_config(cfg, config_type)
|
||||
compare(cfg.value.mandatory(), ['val1.val1'])
|
||||
assert list(cfg.value.mandatory()) == []
|
||||
# assert not list_sessions()
|
||||
|
|
|
|||
|
|
@ -88,7 +88,7 @@ def test_none():
|
|||
assert meta.option('od1.i3').value.get() is conf1.option('od1.i3').value.get() is conf2.option('od1.i3').value.get() is None
|
||||
assert meta.option('od1.i3').owner.get() is conf1.option('od1.i3').owner.get() is conf2.option('od1.i3').owner.get() is owners.default
|
||||
#
|
||||
assert meta.option('od1.i3').value.set(3) == []
|
||||
meta.option('od1.i3').value.set(3)
|
||||
assert meta.option('od1.i3').value.get() == conf1.option('od1.i3').value.get() == conf2.option('od1.i3').value.get() == 3
|
||||
assert meta.option('od1.i3').owner.get() is conf1.option('od1.i3').owner.get() is conf2.option('od1.i3').owner.get() is owners.meta1
|
||||
#
|
||||
|
|
@ -870,7 +870,7 @@ def test_meta_properties_requires_mandatory():
|
|||
meta.option('ip_gw').value.set('1.1.1.2')
|
||||
conf1.option('eth0_method').value.set('dhcp')
|
||||
conf1.property.read_only()
|
||||
assert conf1.value.dict() == {'ip_gw': '1.1.1.2', 'probes': True, 'eth0_method': 'dhcp', 'ip_address': '1.1.1.1', 'ip_eth0': '1.1.1.1'}
|
||||
assert conf1.value.dict(fullpath=True) == {'probes': True, 'eth0_method': 'dhcp', 'ip_address': '1.1.1.1', 'ip_eth0': '1.1.1.1', 'ip_gw': '1.1.1.2'}
|
||||
|
||||
|
||||
def test_meta_callback():
|
||||
|
|
@ -909,51 +909,51 @@ def test_meta_callback_follower():
|
|||
conf1 = Config(maconfig, name='conf1')
|
||||
meta = MetaConfig([conf1])
|
||||
meta.property.read_write()
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val', 'val1.val3': 'val'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
conf1.option('val').value.set('val1')
|
||||
assert conf1.value.dict() == {'val': 'val1', 'val1.val1': [{'val1.val1': 'val1', 'val1.val2': 'val1', 'val1.val3': 'val1'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val1'], 'val1.val1': ['val1'], 'val1.val3': ['val1'], 'val': 'val1'}
|
||||
#
|
||||
conf1.option('val').value.reset()
|
||||
meta.option('val').value.set('val1')
|
||||
assert conf1.value.dict() == {'val': 'val1', 'val1.val1': [{'val1.val1': 'val1', 'val1.val2': 'val1', 'val1.val3': 'val1'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val1'], 'val1.val1': ['val1'], 'val1.val3': ['val1'], 'val': 'val1'}
|
||||
#
|
||||
meta.option('val').value.reset()
|
||||
conf1.option('val1.val2', 0).value.set('val2')
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val2', 'val1.val3': 'val'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
conf1.option('val1.val2', 0).value.reset()
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val', 'val1.val3': 'val'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
meta.option('val1.val2', 0).value.set('val2')
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val2', 'val1.val3': 'val'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
meta.option('val1.val1').value.set(['val'])
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val2', 'val1.val3': 'val'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
conf1.option('val1.val3', 0).value.set('val6')
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val2', 'val1.val3': 'val6'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val'], 'val1.val3': ['val6'], 'val': 'val'}
|
||||
#
|
||||
meta.option('val1.val2', 0).value.reset()
|
||||
conf1.option('val1.val3', 0).value.reset()
|
||||
conf1.option('val1.val1').value.set(['val3'])
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val3', 'val1.val2': 'val3', 'val1.val3': 'val3'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val3'], 'val1.val1': ['val3'], 'val1.val3': ['val3'], 'val': 'val'}
|
||||
#
|
||||
conf1.option('val1.val1').value.reset()
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val', 'val1.val3': 'val'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
meta.option('val1.val1').value.set(['val3'])
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val3', 'val1.val2': 'val3', 'val1.val3': 'val3'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val3'], 'val1.val1': ['val3'], 'val1.val3': ['val3'], 'val': 'val'}
|
||||
#
|
||||
conf1.option('val1.val2', 0).value.set('val2')
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val3', 'val1.val2': 'val2', 'val1.val3': 'val3'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val3'], 'val1.val3': ['val3'], 'val': 'val'}
|
||||
#
|
||||
meta.option('val1.val1').value.set(['val3', 'rah'])
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val3', 'val1.val2': 'val2', 'val1.val3': 'val3'}, {'val1.val1': 'rah', 'val1.val2': 'rah', 'val1.val3': 'rah'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val2', 'rah'], 'val1.val1': ['val3', 'rah'], 'val1.val3': ['val3', 'rah'], 'val': 'val'}
|
||||
#
|
||||
meta.option('val1.val1').value.pop(1)
|
||||
meta.option('val1.val1').value.set(['val4'])
|
||||
assert conf1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val4', 'val1.val2': 'val2', 'val1.val3': 'val4'}]}
|
||||
assert conf1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val4'], 'val1.val3': ['val4'], 'val': 'val'}
|
||||
|
||||
|
||||
def test_meta_reset():
|
||||
|
|
|
|||
|
|
@ -709,51 +709,51 @@ def test_mix_callback_follower():
|
|||
mix = MixConfig(maconfig, [cfg])
|
||||
mix.property.read_write()
|
||||
newcfg1 = mix.config('cfg1')
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val', 'val1.val3': 'val'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
newcfg1.option('val').value.set('val1')
|
||||
assert newcfg1.value.dict() == {'val': 'val1', 'val1.val1': [{'val1.val1': 'val1', 'val1.val2': 'val1', 'val1.val3': 'val1'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val1'], 'val1.val1': ['val1'], 'val1.val3': ['val1'], 'val': 'val1'}
|
||||
#
|
||||
newcfg1.option('val').value.reset()
|
||||
mix.option('val').value.set('val1')
|
||||
assert newcfg1.value.dict() == {'val': 'val1', 'val1.val1': [{'val1.val1': 'val1', 'val1.val2': 'val1', 'val1.val3': 'val1'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val1'], 'val1.val1': ['val1'], 'val1.val3': ['val1'], 'val': 'val1'}
|
||||
#
|
||||
mix.option('val').value.reset()
|
||||
newcfg1.option('val1.val2', 0).value.set('val2')
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val2', 'val1.val3': 'val'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
newcfg1.option('val1.val2', 0).value.reset()
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val', 'val1.val3': 'val'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
mix.option('val1.val2', 0).value.set('val2')
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val2', 'val1.val3': 'val'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
mix.option('val1.val1').value.set(['val'])
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val2', 'val1.val3': 'val'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
newcfg1.option('val1.val3', 0).value.set('val6')
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val2', 'val1.val3': 'val6'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val'], 'val1.val3': ['val6'], 'val': 'val'}
|
||||
#
|
||||
mix.option('val1.val2', 0).value.reset()
|
||||
newcfg1.option('val1.val3', 0).value.reset()
|
||||
newcfg1.option('val1.val1').value.set(['val3'])
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val3', 'val1.val2': 'val3', 'val1.val3': 'val3'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val3'], 'val1.val1': ['val3'], 'val1.val3': ['val3'], 'val': 'val'}
|
||||
#
|
||||
newcfg1.option('val1.val1').value.reset()
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val', 'val1.val2': 'val', 'val1.val3': 'val'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val'], 'val1.val1': ['val'], 'val1.val3': ['val'], 'val': 'val'}
|
||||
#
|
||||
mix.option('val1.val1').value.set(['val3'])
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val3', 'val1.val2': 'val3', 'val1.val3': 'val3'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val3'], 'val1.val1': ['val3'], 'val1.val3': ['val3'], 'val': 'val'}
|
||||
#
|
||||
newcfg1.option('val1.val2', 0).value.set('val2')
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val3', 'val1.val2': 'val2', 'val1.val3': 'val3'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val3'], 'val1.val3': ['val3'], 'val': 'val'}
|
||||
#
|
||||
mix.option('val1.val1').value.set(['val3', 'rah'])
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val3', 'val1.val2': 'val2', 'val1.val3': 'val3'}, {'val1.val1': 'rah', 'val1.val2': 'rah', 'val1.val3': 'rah'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val2', 'rah'], 'val1.val1': ['val3', 'rah'], 'val1.val3': ['val3', 'rah'], 'val': 'val'}
|
||||
#
|
||||
mix.option('val1.val1').value.pop(1)
|
||||
mix.option('val1.val1').value.set(['val4'])
|
||||
assert newcfg1.value.dict() == {'val': 'val', 'val1.val1': [{'val1.val1': 'val4', 'val1.val2': 'val2', 'val1.val3': 'val4'}]}
|
||||
assert newcfg1.value.dict() == {'val1.val2': ['val2'], 'val1.val1': ['val4'], 'val1.val3': ['val4'], 'val': 'val'}
|
||||
|
||||
|
||||
def test_meta_reset():
|
||||
|
|
|
|||
|
|
@ -776,6 +776,20 @@ def test_callback_leader_and_followers_leader_mandatory4(config_type):
|
|||
# assert not list_sessions()
|
||||
|
||||
|
||||
def test_callback_leader_and_followers_leader3():
|
||||
val1 = StrOption('val1', "", multi=True, properties=('mandatory', 'empty'))
|
||||
val2 = StrOption('val2', "", multi=True, default_multi='val2', properties=('expert',))
|
||||
val3 = StrOption('val3', "", Calculation(calc_value, Params(ParamOption(val2), {'index': ParamIndex()})), multi=True)
|
||||
val4 = StrOption('val4', "", Calculation(calc_value, Params(ParamOption(val3), {'index': ParamIndex()})), multi=True)
|
||||
interface1 = Leadership('val1', '', [val1, val2, val3, val4])
|
||||
od1 = OptionDescription('rootconfig', '', [interface1])
|
||||
cfg = Config(od1)
|
||||
cfg.property.read_write()
|
||||
# FIXME cfg = get_config(cfg, config_type)
|
||||
assert list(cfg.value.mandatory()) == ['val1.val1']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
def test_callback_leader_and_followers_leader4():
|
||||
val1 = StrOption('val1', "", ['val1'], multi=True, properties=('mandatory',))
|
||||
val2 = StrOption('val2', "", multi=True, default_multi='val2', properties=('expert', 'mandatory'))
|
||||
|
|
@ -982,7 +996,7 @@ def test_callback_leader_and_followers_leader_callback_disabled():
|
|||
with pytest.raises(ConfigError):
|
||||
cfg.option('val1.val1').value.get()
|
||||
with pytest.raises(ConfigError):
|
||||
cfg.option('val1.val2', 0).value.get()
|
||||
cfg.option('val1.val2').value.get()
|
||||
cfg.property.remove('disabled')
|
||||
cfg.option('val1.val1').value.set([])
|
||||
cfg.property.add('disabled')
|
||||
|
|
|
|||
|
|
@ -219,7 +219,7 @@ def test_setowner_symlinkoption(config_type):
|
|||
assert not cfg.option('tiramisu.symdummy').owner.isdefault()
|
||||
if config_type == 'tiramisu-api':
|
||||
cfg.send()
|
||||
with pytest.raises(APIError):
|
||||
with pytest.raises(ConfigError):
|
||||
cfg_ori.option('tiramisu.symdummy').owner.set('user')
|
||||
# assert not list_sessions()
|
||||
|
||||
|
|
|
|||
|
|
@ -709,7 +709,7 @@ def test_pprint():
|
|||
kwargs={'condition': ParamOption(intoption, todict=True),
|
||||
'expected': ParamValue(1)}),
|
||||
calc_value_property_help)
|
||||
descr2 = OptionDescription("options", "options", [val2], properties=(hidden_property,))
|
||||
descr2 = OptionDescription("options", "", [val2], properties=(hidden_property,))
|
||||
#descr2 = OptionDescription("options", "", [val2], requires=[{'option': intoption, 'expected': 1, 'action': 'hidden'}])
|
||||
|
||||
hidden_property = Calculation(calc_value,
|
||||
|
|
@ -721,7 +721,7 @@ def test_pprint():
|
|||
val3 = StrOption('val3', "", properties=(hidden_property,))
|
||||
#val3 = StrOption('val3', "", requires=[{'option': stroption, 'expected': '2', 'action': 'hidden', 'inverse': True}])
|
||||
|
||||
od1 = OptionDescription("options", "root option", [s, s2, s3, intoption, stroption, descr2, val3])
|
||||
od1 = OptionDescription("options", "", [s, s2, s3, intoption, stroption, descr2, val3])
|
||||
cfg = Config(od1)
|
||||
cfg.property.read_write()
|
||||
cfg.option('int').value.set(1)
|
||||
|
|
|
|||
|
|
@ -1106,19 +1106,39 @@ def test_leadership_requires(config_type):
|
|||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() is None
|
||||
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('255.255.255.255')
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == '255.255.255.255'
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': '192.168.1.2', 'ip_admin_eth0.netmask_admin_eth0': None},
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['192.168.1.2', '192.168.1.2'],
|
||||
'ip_admin_eth0.netmask_admin_eth0': [None, '255.255.255.255']}
|
||||
assert cfg.value.dict(leader_to_list=True) == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': '192.168.1.2', 'ip_admin_eth0.netmask_admin_eth0': None},
|
||||
{'ip_admin_eth0.ip_admin_eth0': '192.168.1.2', 'ip_admin_eth0.netmask_admin_eth0': '255.255.255.255'}]}
|
||||
#
|
||||
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
||||
with pytest.raises(PropertiesOptionError):
|
||||
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': '192.168.1.2',
|
||||
ret = cfg.value.dict()
|
||||
assert set(ret.keys()) == set(['ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
|
||||
assert ret['ip_admin_eth0.ip_admin_eth0'] == ['192.168.1.2', '192.168.1.1']
|
||||
assert len(ret['ip_admin_eth0.netmask_admin_eth0']) == 2
|
||||
assert ret['ip_admin_eth0.netmask_admin_eth0'][0] is None
|
||||
assert isinstance(ret['ip_admin_eth0.netmask_admin_eth0'][1], PropertiesOptionError)
|
||||
del ret['ip_admin_eth0.netmask_admin_eth0'][1]
|
||||
del ret['ip_admin_eth0.netmask_admin_eth0'][0]
|
||||
del ret['ip_admin_eth0.netmask_admin_eth0']
|
||||
assert cfg.value.dict(leader_to_list=True) == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': '192.168.1.2',
|
||||
'ip_admin_eth0.netmask_admin_eth0': None},
|
||||
{'ip_admin_eth0.ip_admin_eth0': '192.168.1.1'}]}
|
||||
#
|
||||
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('255.255.255.255')
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': '192.168.1.2',
|
||||
ret = cfg.value.dict()
|
||||
assert set(ret.keys()) == set(['ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
|
||||
assert ret['ip_admin_eth0.ip_admin_eth0'] == ['192.168.1.2', '192.168.1.1']
|
||||
assert len(ret['ip_admin_eth0.netmask_admin_eth0']) == 2
|
||||
assert ret['ip_admin_eth0.netmask_admin_eth0'][0] == '255.255.255.255'
|
||||
assert isinstance(ret['ip_admin_eth0.netmask_admin_eth0'][1], PropertiesOptionError)
|
||||
del ret['ip_admin_eth0.netmask_admin_eth0'][1]
|
||||
del ret['ip_admin_eth0.netmask_admin_eth0'][0]
|
||||
del ret['ip_admin_eth0.netmask_admin_eth0']
|
||||
assert cfg.value.dict(leader_to_list=True) == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': '192.168.1.2',
|
||||
'ip_admin_eth0.netmask_admin_eth0': '255.255.255.255'},
|
||||
{'ip_admin_eth0.ip_admin_eth0': '192.168.1.1'}]}
|
||||
# assert not list_sessions()
|
||||
|
|
@ -1238,7 +1258,7 @@ def test_leadership_requires_no_leader(config_type):
|
|||
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
|
||||
with pytest.raises(PropertiesOptionError):
|
||||
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()
|
||||
assert cfg.value.dict() == {'activate': False, 'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': '192.168.1.2'}, {'ip_admin_eth0.ip_admin_eth0': '192.168.1.1'}]}
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['192.168.1.2', '192.168.1.1'], 'activate': False}
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -1299,10 +1319,53 @@ def test_leadership_requires_complet(config_type):
|
|||
cfg = get_config(cfg, config_type)
|
||||
cfg.option('options.unicode.unicode').value.set(['test', 'trah'])
|
||||
cfg.option('options.unicode.unicode2', 0).value.set('test')
|
||||
assert cfg.value.dict() == {'options.unicode.unicode': [{'options.unicode.unicode': 'test', 'options.unicode.unicode1': None, 'options.unicode.unicode2': 'test', 'options.unicode.unicode3': None, 'options.unicode.unicode4': None}, {'options.unicode.unicode': 'trah', 'options.unicode.unicode1': None, 'options.unicode.unicode2': None}], 'options.unicodetoto': None}
|
||||
dico = cfg.value.dict()
|
||||
assert dico.keys() == set(['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicode.unicode6', 'options.unicode.unicode7', 'options.unicodetoto'])
|
||||
assert dico['options.unicode.unicode'] == ['test', 'trah']
|
||||
assert dico['options.unicode.unicode1'] == [None, None]
|
||||
assert dico['options.unicode.unicode2'] == ['test', None]
|
||||
assert dico['options.unicode.unicode3'][0] is None
|
||||
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
||||
assert dico['options.unicode.unicode4'][0] is None
|
||||
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode6'][0], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode6'][1], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode7'][0], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode7'][1], PropertiesOptionError)
|
||||
assert dico['options.unicodetoto'] is None
|
||||
del dico['options.unicode.unicode3'][1]
|
||||
del dico['options.unicode.unicode3']
|
||||
del dico['options.unicode.unicode4'][1]
|
||||
del dico['options.unicode.unicode4']
|
||||
del dico['options.unicode.unicode6'][1]
|
||||
del dico['options.unicode.unicode6'][0]
|
||||
del dico['options.unicode.unicode7'][1]
|
||||
del dico['options.unicode.unicode7'][0]
|
||||
#
|
||||
cfg.option('options.unicodetoto').value.set('test')
|
||||
assert cfg.value.dict() == {'options.unicode.unicode': [{'options.unicode.unicode': 'test', 'options.unicode.unicode1': None, 'options.unicode.unicode2': 'test', 'options.unicode.unicode3': None, 'options.unicode.unicode4': None, 'options.unicode.unicode5': None, 'options.unicode.unicode6': None, 'options.unicode.unicode7': None}, {'options.unicode.unicode': 'trah', 'options.unicode.unicode1': None, 'options.unicode.unicode2': None, 'options.unicode.unicode5': None}], 'options.unicodetoto': 'test'}
|
||||
dico = cfg.value.dict()
|
||||
assert dico.keys() == set(['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicode.unicode5', 'options.unicode.unicode6', 'options.unicode.unicode7', 'options.unicodetoto'])
|
||||
assert dico['options.unicode.unicode'] == ['test', 'trah']
|
||||
assert dico['options.unicode.unicode1'] == [None, None]
|
||||
assert dico['options.unicode.unicode2'] == ['test', None]
|
||||
assert dico['options.unicode.unicode3'][0] is None
|
||||
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
||||
assert dico['options.unicode.unicode4'][0] is None
|
||||
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
||||
assert dico['options.unicode.unicode5'] == [None, None]
|
||||
assert dico['options.unicode.unicode6'][0] is None
|
||||
assert isinstance(dico['options.unicode.unicode6'][1], PropertiesOptionError)
|
||||
assert dico['options.unicode.unicode7'][0] is None
|
||||
assert isinstance(dico['options.unicode.unicode7'][1], PropertiesOptionError)
|
||||
assert dico['options.unicodetoto'] == 'test'
|
||||
del dico['options.unicode.unicode3'][1]
|
||||
del dico['options.unicode.unicode3']
|
||||
del dico['options.unicode.unicode4'][1]
|
||||
del dico['options.unicode.unicode4']
|
||||
del dico['options.unicode.unicode6'][1]
|
||||
del dico['options.unicode.unicode6'][0]
|
||||
del dico['options.unicode.unicode7'][1]
|
||||
del dico['options.unicode.unicode7'][0]
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
@ -1339,24 +1402,91 @@ def test_leadership_requires_transitive1(config_type):
|
|||
cfg = Config(od1)
|
||||
cfg.property.read_write()
|
||||
cfg = get_config(cfg, config_type)
|
||||
assert cfg.value.dict() == {'options.unicode.unicode': [], 'options.unicodetoto': None}
|
||||
assert cfg.value.dict() == {'options.unicode.unicode': [], 'options.unicode.unicode1': [], 'options.unicode.unicode3': [], 'options.unicode.unicode4': [], 'options.unicodetoto': None}
|
||||
#
|
||||
cfg.option('options.unicodetoto').value.set('test')
|
||||
assert cfg.value.dict() == {'options.unicode.unicode': [], 'options.unicodetoto': 'test'}
|
||||
assert cfg.value.dict() == {'options.unicode.unicode': [], 'options.unicode.unicode1': [], 'options.unicode.unicode2': [], 'options.unicode.unicode3': [], 'options.unicode.unicode4': [], 'options.unicodetoto': 'test'}
|
||||
#
|
||||
cfg.option('options.unicode.unicode').value.set(['a', 'b', 'c'])
|
||||
assert cfg.value.dict() == {'options.unicode.unicode': [{'options.unicode.unicode': 'a', 'options.unicode.unicode1': None, 'options.unicode.unicode2': None}, {'options.unicode.unicode': 'b', 'options.unicode.unicode1': None, 'options.unicode.unicode2': None}, {'options.unicode.unicode': 'c', 'options.unicode.unicode1': None, 'options.unicode.unicode2': None}], 'options.unicodetoto': 'test'}
|
||||
dico = cfg.value.dict()
|
||||
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
||||
assert dico['options.unicodetoto'] == 'test'
|
||||
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
||||
assert dico['options.unicode.unicode1'] == [None, None, None]
|
||||
assert dico['options.unicode.unicode2'] == [None, None, None]
|
||||
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
||||
del (dico['options.unicode.unicode3'][2])
|
||||
del (dico['options.unicode.unicode3'][1])
|
||||
del (dico['options.unicode.unicode3'][0])
|
||||
del (dico['options.unicode.unicode4'][2])
|
||||
del (dico['options.unicode.unicode4'][1])
|
||||
del (dico['options.unicode.unicode4'][0])
|
||||
|
||||
cfg.option('options.unicode.unicode2', 1).value.set('test')
|
||||
cfg.option('options.unicode.unicode3', 1).value.set('test')
|
||||
assert cfg.value.dict() == {'options.unicode.unicode': [{'options.unicode.unicode': 'a', 'options.unicode.unicode1': None, 'options.unicode.unicode2': None}, {'options.unicode.unicode': 'b', 'options.unicode.unicode1': None, 'options.unicode.unicode2': 'test', 'options.unicode.unicode3': 'test', 'options.unicode.unicode4': None}, {'options.unicode.unicode': 'c', 'options.unicode.unicode1': None, 'options.unicode.unicode2': None}], 'options.unicodetoto': 'test'}
|
||||
dico = cfg.value.dict()
|
||||
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
||||
assert dico['options.unicodetoto'] == 'test'
|
||||
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
||||
assert dico['options.unicode.unicode1'] == [None, None, None]
|
||||
assert dico['options.unicode.unicode2'] == [None, 'test', None]
|
||||
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
||||
assert dico['options.unicode.unicode3'][1] == 'test'
|
||||
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
||||
assert dico['options.unicode.unicode4'][1] == None
|
||||
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
||||
del (dico['options.unicode.unicode3'][2])
|
||||
del (dico['options.unicode.unicode3'][1])
|
||||
del (dico['options.unicode.unicode3'][0])
|
||||
del (dico['options.unicode.unicode4'][2])
|
||||
del (dico['options.unicode.unicode4'][1])
|
||||
del (dico['options.unicode.unicode4'][0])
|
||||
#
|
||||
cfg.option('options.unicode.unicode2', 1).value.set('rah')
|
||||
assert cfg.value.dict() == {'options.unicode.unicode': [{'options.unicode.unicode': 'a', 'options.unicode.unicode1': None, 'options.unicode.unicode2': None}, {'options.unicode.unicode': 'b', 'options.unicode.unicode1': None, 'options.unicode.unicode2': 'rah'}, {'options.unicode.unicode': 'c', 'options.unicode.unicode1': None, 'options.unicode.unicode2': None}], 'options.unicodetoto': 'test'}
|
||||
dico = cfg.value.dict()
|
||||
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
||||
assert dico['options.unicodetoto'] == 'test'
|
||||
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
||||
assert dico['options.unicode.unicode1'] == [None, None, None]
|
||||
assert dico['options.unicode.unicode2'] == [None, 'rah', None]
|
||||
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
||||
del (dico['options.unicode.unicode3'][2])
|
||||
del (dico['options.unicode.unicode3'][1])
|
||||
del (dico['options.unicode.unicode3'][0])
|
||||
del (dico['options.unicode.unicode4'][2])
|
||||
del (dico['options.unicode.unicode4'][1])
|
||||
del (dico['options.unicode.unicode4'][0])
|
||||
#
|
||||
cfg.option('options.unicode.unicode2', 1).value.set('test')
|
||||
cfg.option('options.unicodetoto').value.set('rah')
|
||||
assert cfg.value.dict() == {'options.unicode.unicode': [{'options.unicode.unicode': 'a', 'options.unicode.unicode1': None}, {'options.unicode.unicode': 'b', 'options.unicode.unicode1': None}, {'options.unicode.unicode': 'c', 'options.unicode.unicode1': None}], 'options.unicodetoto': 'rah'}
|
||||
dico = cfg.value.dict()
|
||||
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
||||
assert dico['options.unicodetoto'] == 'rah'
|
||||
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
||||
assert dico['options.unicode.unicode1'] == [None, None, None]
|
||||
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
||||
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
||||
del (dico['options.unicode.unicode3'][2])
|
||||
del (dico['options.unicode.unicode3'][1])
|
||||
del (dico['options.unicode.unicode3'][0])
|
||||
del (dico['options.unicode.unicode4'][2])
|
||||
del (dico['options.unicode.unicode4'][1])
|
||||
del (dico['options.unicode.unicode4'][0])
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -11,6 +11,7 @@ try:
|
|||
except:
|
||||
tiramisu_version = 2
|
||||
from tiramisu import Config
|
||||
from tiramisu.config import SubConfig
|
||||
from tiramisu.option import ChoiceOption, BoolOption, IntOption, FloatOption,\
|
||||
StrOption, SymLinkOption, StrOption, IPOption, OptionDescription, \
|
||||
PortOption, NetworkOption, NetmaskOption, DomainnameOption, EmailOption, \
|
||||
|
|
@ -157,11 +158,32 @@ def test_slots_option_readonly():
|
|||
# assert slots == set(OptionDescription.__slots__)
|
||||
|
||||
|
||||
def test_slots_config():
|
||||
od1 = OptionDescription('a', '', [])
|
||||
od2 = OptionDescription('a', '', [od1])
|
||||
cfg = Config(od2)
|
||||
with pytest.raises(AttributeError):
|
||||
cfg._config_bag.context.x = 1
|
||||
with pytest.raises(AttributeError):
|
||||
cfg._config_bag.context.cfgimpl_x = 1
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(od2,
|
||||
'a',
|
||||
ConfigBag(cfg._config_bag.context, None, None))
|
||||
sc = cfg._config_bag.context.get_subconfig(option_bag)
|
||||
assert isinstance(sc, SubConfig)
|
||||
with pytest.raises(AttributeError):
|
||||
sc.x = 1
|
||||
with pytest.raises(AttributeError):
|
||||
sc.cfgimpl_x = 1
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
def test_slots_setting():
|
||||
od1 = OptionDescription('a', '', [])
|
||||
od2 = OptionDescription('a', '', [od1])
|
||||
cfg = Config(od2)
|
||||
s = cfg._config_bag.context.get_settings()
|
||||
s = cfg._config_bag.context.cfgimpl_get_settings()
|
||||
s
|
||||
with pytest.raises(AttributeError):
|
||||
s.x = 1
|
||||
|
|
@ -172,7 +194,7 @@ def test_slots_value():
|
|||
od1 = OptionDescription('a', '', [])
|
||||
od2 = OptionDescription('a', '', [od1])
|
||||
cfg = Config(od2)
|
||||
v = cfg._config_bag.context.get_values()
|
||||
v = cfg._config_bag.context.cfgimpl_get_values()
|
||||
v
|
||||
with pytest.raises(AttributeError):
|
||||
v.x = 1
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ def test_symlink_assign_option(config_type):
|
|||
[linkopt, OptionDescription("s1", "", [boolopt])])
|
||||
cfg = Config(od1)
|
||||
cfg = get_config(cfg, config_type)
|
||||
with pytest.raises(APIError):
|
||||
with pytest.raises(ConfigError):
|
||||
cfg.option('c').value.set(True)
|
||||
# assert not list_sessions()
|
||||
|
||||
|
|
@ -55,7 +55,7 @@ def test_symlink_del_option(config_type):
|
|||
[linkopt, OptionDescription("s1", "", [boolopt])])
|
||||
cfg = Config(od1)
|
||||
cfg = get_config(cfg, config_type)
|
||||
with pytest.raises(APIError):
|
||||
with pytest.raises(ConfigError):
|
||||
cfg.option('c').value.reset()
|
||||
# assert not list_sessions()
|
||||
|
||||
|
|
@ -191,7 +191,7 @@ def test_symlink_assign(config_type):
|
|||
[linkopt, OptionDescription("s1", "", [boolopt])])
|
||||
cfg = Config(od1)
|
||||
cfg = get_config(cfg, config_type)
|
||||
with pytest.raises(APIError):
|
||||
with pytest.raises(ConfigError):
|
||||
cfg.option('c').value.set(True)
|
||||
# assert not list_sessions()
|
||||
|
||||
|
|
@ -246,9 +246,9 @@ def test_symlink_with_leader(config_type):
|
|||
od1 = OptionDescription('root', '', [interface1, leader])
|
||||
cfg = Config(od1)
|
||||
cfg = get_config(cfg, config_type)
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'leader': []}
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'leader': []}
|
||||
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': 'val1', 'ip_admin_eth0.netmask_admin_eth0': None}, {'ip_admin_eth0.ip_admin_eth0': 'val2', 'ip_admin_eth0.netmask_admin_eth0': None}], 'leader': ['val1', 'val2']}
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'leader': ['val1', 'val2']}
|
||||
cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
|
||||
with pytest.raises(APIError):
|
||||
cfg.option('leader').value.pop(0)
|
||||
|
|
@ -263,36 +263,36 @@ def test_symlink_with_follower(config_type):
|
|||
od1 = OptionDescription('root', '', [interface1, follower])
|
||||
cfg = Config(od1)
|
||||
cfg = get_config(cfg, config_type)
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'follower': []}
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'follower': []}
|
||||
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': 'val1', 'ip_admin_eth0.netmask_admin_eth0': None}, {'ip_admin_eth0.ip_admin_eth0': 'val2', 'ip_admin_eth0.netmask_admin_eth0': None}], 'follower': [None, None]}
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'follower': [None, None]}
|
||||
#
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == 'default'
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).owner.get() == 'default'
|
||||
with pytest.raises(APIError):
|
||||
assert cfg.option('follower', 0).owner.get() == 'default'
|
||||
assert cfg.option('follower').owner.get() == 'default'
|
||||
assert cfg.option('follower', 1).owner.get() == 'default'
|
||||
assert cfg.option('follower').owner.get() == ['default', 'default']
|
||||
#
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == None
|
||||
with pytest.raises(APIError):
|
||||
assert cfg.option('follower', 0).value.get() == None
|
||||
assert cfg.option('follower', 1).value.get() == None
|
||||
assert cfg.option('follower').value.get() == [None, None]
|
||||
#
|
||||
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('val3')
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': 'val1', 'ip_admin_eth0.netmask_admin_eth0': None}, {'ip_admin_eth0.ip_admin_eth0': 'val2', 'ip_admin_eth0.netmask_admin_eth0': 'val3'}], 'follower': [None, 'val3']}
|
||||
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, 'val3'], 'follower': [None, 'val3']}
|
||||
#
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == 'val3'
|
||||
with pytest.raises(APIError):
|
||||
assert cfg.option('follower', 0).value.get() == None
|
||||
assert cfg.option('follower', 1).value.get() == 'val3'
|
||||
assert cfg.option('follower').value.get() == [None, 'val3']
|
||||
#
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == 'default'
|
||||
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).owner.get() == 'user'
|
||||
with pytest.raises(APIError):
|
||||
assert cfg.option('follower', 0).owner.get() == 'default'
|
||||
assert cfg.option('follower').owner.get() == 'user'
|
||||
assert cfg.option('follower', 1).owner.get() == 'user'
|
||||
assert cfg.option('follower').owner.get() == ['default', 'user']
|
||||
# assert not list_sessions()
|
||||
|
||||
|
||||
|
|
|
|||
970
tiramisu/api.py
970
tiramisu/api.py
File diff suppressed because it is too large
Load diff
|
|
@ -243,12 +243,7 @@ def manager_callback(callbk: Param,
|
|||
return index
|
||||
return None
|
||||
|
||||
def calc_self(callbk,
|
||||
option,
|
||||
index,
|
||||
value,
|
||||
config_bag,
|
||||
):
|
||||
def calc_self(callbk, option, index, value, config_bag):
|
||||
# index must be apply only if follower
|
||||
is_follower = option.impl_is_follower()
|
||||
apply_index = calc_index(callbk, index, is_follower)
|
||||
|
|
@ -256,40 +251,11 @@ def manager_callback(callbk: Param,
|
|||
if config_bag is undefined:
|
||||
return undefined
|
||||
path = option.impl_getpath()
|
||||
option_bag = OptionBag(option,
|
||||
None,
|
||||
config_bag,
|
||||
properties=None,
|
||||
)
|
||||
properties = config_bag.context.get_settings().getproperties(option_bag,
|
||||
uncalculated=True,
|
||||
)
|
||||
parent_option_bag, option_bag = get_option_bag(config_bag,
|
||||
option_bag = get_option_bag(config_bag,
|
||||
option,
|
||||
callbk,
|
||||
apply_index,
|
||||
True,
|
||||
properties=properties,
|
||||
)
|
||||
if option.impl_is_follower() and apply_index is None:
|
||||
new_value = []
|
||||
for idx in range(config_bag.context.get_length_leadership(parent_option_bag)):
|
||||
parent_option_bag, option_bag = get_option_bag(config_bag,
|
||||
option,
|
||||
callbk,
|
||||
idx,
|
||||
True,
|
||||
properties=properties,
|
||||
)
|
||||
new_value.append(get_value(callbk,
|
||||
option_bag,
|
||||
path,
|
||||
))
|
||||
else:
|
||||
new_value = get_value(callbk,
|
||||
option_bag,
|
||||
path,
|
||||
)
|
||||
True)
|
||||
new_value = get_value(callbk, option_bag, path)
|
||||
if apply_index is None and is_follower:
|
||||
new_value[index] = value
|
||||
value = new_value
|
||||
|
|
@ -303,7 +269,8 @@ def manager_callback(callbk: Param,
|
|||
):
|
||||
try:
|
||||
# get value
|
||||
value = config_bag.context.get_value(option_bag)
|
||||
value = config_bag.context.getattr(path,
|
||||
option_bag)
|
||||
except PropertiesOptionError as err:
|
||||
# raise PropertiesOptionError (which is catched) because must not add value None in carry_out_calculation
|
||||
if callbk.notraisepropertyerror or callbk.raisepropertyerror:
|
||||
|
|
@ -317,18 +284,15 @@ def manager_callback(callbk: Param,
|
|||
# cannot acces, simulate a propertyerror
|
||||
raise PropertiesOptionError(option_bag,
|
||||
['configerror'],
|
||||
config_bag.context.get_settings(),
|
||||
config_bag.context.cfgimpl_get_settings(),
|
||||
)
|
||||
raise ConfigError(_(f'unable to get value for calculating "{option_bag.option.impl_get_display_name()}", {err}')) from err
|
||||
return value
|
||||
|
||||
def get_option_bag(config_bag,
|
||||
opt,
|
||||
callbk,
|
||||
index_,
|
||||
self_calc,
|
||||
properties=undefined,
|
||||
):
|
||||
self_calc):
|
||||
# don't validate if option is option that we tried to validate
|
||||
config_bag = config_bag.copy()
|
||||
if for_settings:
|
||||
|
|
@ -336,51 +300,27 @@ def manager_callback(callbk: Param,
|
|||
config_bag.set_permissive()
|
||||
if not for_settings:
|
||||
config_bag.properties -= {'warnings'}
|
||||
if self_calc:
|
||||
config_bag.unrestraint()
|
||||
config_bag.remove_validation()
|
||||
root_option_bag = OptionBag(config_bag.context.get_description(),
|
||||
None,
|
||||
config_bag,
|
||||
)
|
||||
try:
|
||||
options_bag = config_bag.context.get_sub_option_bag(root_option_bag,
|
||||
opt.impl_getpath(),
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(opt,
|
||||
index_,
|
||||
validate_properties=not self_calc,
|
||||
properties=properties,
|
||||
)
|
||||
except PropertiesOptionError as err:
|
||||
# raise PropertiesOptionError (which is catched) because must not add value None in carry_out_calculation
|
||||
if callbk.notraisepropertyerror or callbk.raisepropertyerror:
|
||||
raise err from err
|
||||
raise ConfigError(_('unable to carry out a calculation for "{}"'
|
||||
', {}').format(option.impl_get_display_name(), err), err) from err
|
||||
except ValueError as err:
|
||||
raise ValueError(_('the option "{0}" is used in a calculation but is invalid ({1})').format(option.impl_get_display_name(), err)) from err
|
||||
except AttributeError as err:
|
||||
if isinstance(callbk, ParamDynOption) and callbk.optional:
|
||||
# cannot acces, simulate a propertyerror
|
||||
raise PropertiesOptionError(options_bag[-1],
|
||||
['configerror'],
|
||||
config_bag.context.get_settings(),
|
||||
)
|
||||
raise ConfigError(_(f'unable to get value for calculating "{option.impl_get_display_name()}", {err}')) from err
|
||||
if self_calc:
|
||||
if len(options_bag) > 1:
|
||||
parent_option_bag = options_bag[-2]
|
||||
config_bag)
|
||||
if not self_calc:
|
||||
option_bag.properties = config_bag.context.cfgimpl_get_settings().getproperties(option_bag)
|
||||
else:
|
||||
parent_option_bag = None
|
||||
return parent_option_bag, options_bag[-1]
|
||||
else:
|
||||
return options_bag[-1]
|
||||
option_bag.config_bag.unrestraint()
|
||||
option_bag.config_bag.remove_validation()
|
||||
# if we are in properties calculation, cannot calculated properties
|
||||
option_bag.properties = config_bag.context.cfgimpl_get_settings().getproperties(option_bag,
|
||||
apply_requires=False)
|
||||
return option_bag
|
||||
|
||||
if isinstance(callbk, ParamValue):
|
||||
return callbk.value
|
||||
|
||||
if isinstance(callbk, ParamInformation):
|
||||
if isinstance(callbk, ParamSelfInformation):
|
||||
option_bag = OptionBag(option,
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(option,
|
||||
index,
|
||||
config_bag,
|
||||
)
|
||||
|
|
@ -408,17 +348,11 @@ def manager_callback(callbk: Param,
|
|||
if isinstance(callbk, ParamSelfOption):
|
||||
if leadership_must_have_index and option.impl_is_follower() and index is None:
|
||||
raise Break()
|
||||
value = calc_self(callbk,
|
||||
option,
|
||||
index,
|
||||
orig_value,
|
||||
config_bag,
|
||||
)
|
||||
value = calc_self(callbk, option, index, orig_value, config_bag)
|
||||
if not callbk.todict:
|
||||
return value
|
||||
return {'name': option.impl_get_display_name(),
|
||||
'value': value,
|
||||
}
|
||||
'value': value}
|
||||
|
||||
if isinstance(callbk, ParamOption):
|
||||
callbk_option = callbk.option
|
||||
|
|
@ -431,8 +365,7 @@ def manager_callback(callbk: Param,
|
|||
suffix = callbk.suffix
|
||||
callbk_option = callbk_option.to_dynoption(rootpath,
|
||||
suffix,
|
||||
subdyn,
|
||||
)
|
||||
subdyn)
|
||||
found = True
|
||||
elif option.impl_is_dynsymlinkoption():
|
||||
rootpath = option.rootpath
|
||||
|
|
@ -486,10 +419,8 @@ def manager_callback(callbk: Param,
|
|||
path = callbk_option.impl_getpath()
|
||||
option_bag = get_option_bag(config_bag,
|
||||
callbk_option,
|
||||
callbk,
|
||||
index_,
|
||||
False,
|
||||
)
|
||||
False)
|
||||
value = get_value(callbk,
|
||||
option_bag,
|
||||
path,
|
||||
|
|
@ -571,8 +502,7 @@ def carry_out_calculation(option,
|
|||
allow_value_error,
|
||||
force_value_warning,
|
||||
args,
|
||||
kwargs,
|
||||
)
|
||||
kwargs)
|
||||
if isinstance(ret, list) and not option.impl_is_dynoptiondescription() and \
|
||||
option.impl_is_follower() and not option.impl_is_submulti():
|
||||
if args or kwargs:
|
||||
|
|
|
|||
|
|
@ -52,8 +52,7 @@ class Cache:
|
|||
index,
|
||||
props,
|
||||
self_props,
|
||||
type_,
|
||||
):
|
||||
type_):
|
||||
no_cache = False, None, False
|
||||
if 'cache' in props or type_ == 'context_props':
|
||||
values = self._cache.get(path)
|
||||
|
|
|
|||
1378
tiramisu/config.py
1378
tiramisu/config.py
File diff suppressed because it is too large
Load diff
|
|
@ -128,7 +128,7 @@ class PropertiesOptionError(AttributeError):
|
|||
# Exceptions for a Config
|
||||
class ConfigError(Exception):
|
||||
"""attempt to change an option's owner without a value
|
||||
or in case of `_descr` is None
|
||||
or in case of `_cfgimpl_descr` is None
|
||||
or if a calculation cannot be carried out"""
|
||||
def __init__(self,
|
||||
exp,
|
||||
|
|
|
|||
|
|
@ -157,9 +157,8 @@ class Base:
|
|||
return getattr(self, '_properties', frozenset())
|
||||
|
||||
def _setsubdyn(self,
|
||||
subdyn,
|
||||
) -> None:
|
||||
self._subdyn = subdyn
|
||||
subdyn) -> None:
|
||||
self._subdyn = weakref.ref(subdyn)
|
||||
|
||||
def issubdyn(self) -> bool:
|
||||
return getattr(self, '_subdyn', None) is not None
|
||||
|
|
@ -296,7 +295,7 @@ class BaseOption(Base):
|
|||
config_bag: 'OptionBag',
|
||||
resetted_opts: List[Base]) -> None:
|
||||
context = config_bag.context
|
||||
context.properties_cache.delcache(path)
|
||||
context._impl_properties_cache.delcache(path)
|
||||
context._impl_permissives_cache.delcache(path)
|
||||
if not self.impl_is_optiondescription():
|
||||
context._impl_values_cache.delcache(path)
|
||||
|
|
|
|||
|
|
@ -19,7 +19,6 @@
|
|||
# the whole pypy projet is under MIT licence
|
||||
# ____________________________________________________________
|
||||
import re
|
||||
import weakref
|
||||
from typing import List, Callable, Any
|
||||
from itertools import chain
|
||||
from ..autolib import ParamOption
|
||||
|
|
@ -44,18 +43,24 @@ class DynOptionDescription(OptionDescription):
|
|||
doc: str,
|
||||
children: List[BaseOption],
|
||||
suffixes: Calculation,
|
||||
properties=None,
|
||||
) -> None:
|
||||
properties=None) -> None:
|
||||
|
||||
super().__init__(name,
|
||||
doc,
|
||||
children,
|
||||
properties,
|
||||
)
|
||||
properties)
|
||||
# check children + set relation to this dynoptiondescription
|
||||
wself = weakref.ref(self)
|
||||
for child in children:
|
||||
child._setsubdyn(wself)
|
||||
if isinstance(child, OptionDescription):
|
||||
if __debug__ and child.impl_get_group_type() != groups.leadership:
|
||||
raise ConfigError(_('cannot set optiondescription in a '
|
||||
'dynoptiondescription'))
|
||||
for chld in child._children[1]:
|
||||
chld._setsubdyn(self)
|
||||
if __debug__ and child.impl_is_symlinkoption():
|
||||
raise ConfigError(_('cannot set symlinkoption in a '
|
||||
'dynoptiondescription'))
|
||||
child._setsubdyn(self)
|
||||
# add suffixes
|
||||
if __debug__ and not isinstance(suffixes, Calculation):
|
||||
raise ConfigError(_('suffixes in dynoptiondescription has to be a calculation'))
|
||||
|
|
@ -79,11 +84,10 @@ class DynOptionDescription(OptionDescription):
|
|||
|
||||
def get_suffixes(self,
|
||||
config_bag: ConfigBag) -> List[str]:
|
||||
option_bag = OptionBag(self,
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(self,
|
||||
None,
|
||||
config_bag,
|
||||
properties=None,
|
||||
)
|
||||
config_bag)
|
||||
values = self._suffixes.execute(option_bag)
|
||||
if values is None:
|
||||
values = []
|
||||
|
|
|
|||
|
|
@ -96,13 +96,6 @@ class Leadership(OptionDescription):
|
|||
if prop not in ALLOWED_LEADER_PROPERTIES and not isinstance(prop, Calculation):
|
||||
raise LeadershipError(_('leader cannot have "{}" property').format(prop))
|
||||
|
||||
def _setsubdyn(self,
|
||||
subdyn,
|
||||
) -> None:
|
||||
for chld in self._children[1]:
|
||||
chld._setsubdyn(subdyn)
|
||||
self._subdyn = subdyn
|
||||
|
||||
def is_leader(self,
|
||||
opt: Option) -> bool:
|
||||
leader = self.get_leader()
|
||||
|
|
@ -127,10 +120,11 @@ class Leadership(OptionDescription):
|
|||
config_bag = option_bag.config_bag.copy()
|
||||
config_bag.remove_validation()
|
||||
for follower in self.get_followers():
|
||||
soption_bag = OptionBag(follower,
|
||||
soption_bag = OptionBag()
|
||||
soption_bag.set_option(follower,
|
||||
None,
|
||||
config_bag,
|
||||
)
|
||||
config_bag)
|
||||
soption_bag.properties = config_bag.context.cfgimpl_get_settings().getproperties(soption_bag)
|
||||
values.reset(soption_bag)
|
||||
|
||||
def follower_force_store_value(self,
|
||||
|
|
@ -140,28 +134,29 @@ class Leadership(OptionDescription):
|
|||
owner,
|
||||
dyn=None,
|
||||
) -> None:
|
||||
settings = option_bag.config_bag.context.get_settings()
|
||||
settings = option_bag.config_bag.context.cfgimpl_get_settings()
|
||||
if value:
|
||||
if dyn is None:
|
||||
dyn = self
|
||||
for idx, follower in enumerate(dyn.get_children(option_bag.config_bag)):
|
||||
foption_bag = OptionBag(follower,
|
||||
foption_bag = OptionBag()
|
||||
foption_bag.set_option(follower,
|
||||
None,
|
||||
option_bag.config_bag,
|
||||
)
|
||||
if 'force_store_value' in foption_bag.properties:
|
||||
option_bag.config_bag)
|
||||
if 'force_store_value' in settings.getproperties(foption_bag):
|
||||
if idx == 0:
|
||||
indexes = [None]
|
||||
else:
|
||||
indexes = range(len(value))
|
||||
for index in indexes:
|
||||
foption_bag_index = OptionBag(follower,
|
||||
foption_bag = OptionBag()
|
||||
foption_bag.set_option(follower,
|
||||
index,
|
||||
option_bag.config_bag,
|
||||
)
|
||||
values.set_storage_value(foption_bag_index.path,
|
||||
option_bag.config_bag)
|
||||
foption_bag.properties = settings.getproperties(foption_bag)
|
||||
values.set_storage_value(foption_bag.path,
|
||||
index,
|
||||
values.getvalue(foption_bag_index),
|
||||
values.getvalue(foption_bag),
|
||||
owner,
|
||||
)
|
||||
|
||||
|
|
@ -169,8 +164,7 @@ class Leadership(OptionDescription):
|
|||
values: Values,
|
||||
index: int,
|
||||
option_bag: OptionBag,
|
||||
followers: Optional[List[Option]]=undefined,
|
||||
) -> None:
|
||||
followers: Optional[List[Option]]=undefined) -> None:
|
||||
if followers is undefined:
|
||||
# followers are not undefined only in SynDynLeadership
|
||||
followers = self.get_followers()
|
||||
|
|
@ -179,14 +173,14 @@ class Leadership(OptionDescription):
|
|||
for follower in followers:
|
||||
follower_path = follower.impl_getpath()
|
||||
followerlen = values.get_max_length(follower_path)
|
||||
soption_bag = OptionBag(follower,
|
||||
soption_bag = OptionBag()
|
||||
soption_bag.set_option(follower,
|
||||
index,
|
||||
config_bag,
|
||||
properties=set(), # do not check force_default_on_freeze or force_metaconfig_on_freeze
|
||||
)
|
||||
config_bag)
|
||||
# do not check force_default_on_freeze or force_metaconfig_on_freeze
|
||||
soption_bag.properties = set()
|
||||
is_default = values.is_default_owner(soption_bag,
|
||||
validate_meta=False,
|
||||
)
|
||||
validate_meta=False)
|
||||
if not is_default and followerlen > index:
|
||||
values.resetvalue_index(follower_path,
|
||||
index,
|
||||
|
|
@ -203,22 +197,19 @@ class Leadership(OptionDescription):
|
|||
def reset_cache(self,
|
||||
path: str,
|
||||
config_bag: 'ConfigBag',
|
||||
resetted_opts: List[Option],
|
||||
) -> None:
|
||||
resetted_opts: List[Option]) -> None:
|
||||
self._reset_cache(path,
|
||||
self.get_leader(),
|
||||
self.get_followers(),
|
||||
config_bag,
|
||||
resetted_opts,
|
||||
)
|
||||
resetted_opts)
|
||||
|
||||
def _reset_cache(self,
|
||||
path: str,
|
||||
leader: Option,
|
||||
followers: List[Option],
|
||||
config_bag: 'ConfigBag',
|
||||
resetted_opts: List[Option],
|
||||
) -> None:
|
||||
resetted_opts: List[Option]) -> None:
|
||||
super().reset_cache(path,
|
||||
config_bag,
|
||||
resetted_opts)
|
||||
|
|
|
|||
|
|
@ -121,11 +121,10 @@ class Option(BaseOption):
|
|||
def test_multi_value(value):
|
||||
if isinstance(value, Calculation):
|
||||
return
|
||||
option_bag = OptionBag(self,
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(self,
|
||||
None,
|
||||
undefined,
|
||||
properties=None,
|
||||
)
|
||||
undefined)
|
||||
try:
|
||||
self.validate(value)
|
||||
self.sync_validate_with_option(value,
|
||||
|
|
@ -153,11 +152,10 @@ class Option(BaseOption):
|
|||
else:
|
||||
test_multi_value(default_multi)
|
||||
_setattr(self, '_default_multi', default_multi)
|
||||
option_bag = OptionBag(self,
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(self,
|
||||
None,
|
||||
undefined,
|
||||
properties=None,
|
||||
)
|
||||
undefined)
|
||||
self.sync_impl_validate(default,
|
||||
option_bag)
|
||||
self.sync_impl_validate(default,
|
||||
|
|
@ -516,10 +514,10 @@ class Option(BaseOption):
|
|||
def to_dynoption(self,
|
||||
rootpath: str,
|
||||
suffix: str,
|
||||
dyn_parent,
|
||||
ori_dyn,
|
||||
) -> SynDynOption:
|
||||
return SynDynOption(self,
|
||||
rootpath,
|
||||
suffix,
|
||||
dyn_parent,
|
||||
ori_dyn,
|
||||
)
|
||||
|
|
|
|||
|
|
@ -79,8 +79,7 @@ class CacheOptionDescription(BaseOption):
|
|||
cache_option,
|
||||
force_store_values,
|
||||
dependencies_information,
|
||||
display_name,
|
||||
)
|
||||
display_name)
|
||||
else:
|
||||
for information in option.get_dependencies_information():
|
||||
dependencies_information.setdefault(information, []).append(option)
|
||||
|
|
@ -125,22 +124,21 @@ class CacheOptionDescription(BaseOption):
|
|||
suffix,
|
||||
dynopt,
|
||||
)
|
||||
doption_bag = OptionBag(doption,
|
||||
doption_bag = OptionBag()
|
||||
doption_bag.set_option(doption,
|
||||
None,
|
||||
config_bag,
|
||||
properties=None,
|
||||
)
|
||||
yield doption_bag
|
||||
else:
|
||||
option_bag = OptionBag(option,
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(option,
|
||||
None,
|
||||
config_bag,
|
||||
properties=None,
|
||||
)
|
||||
config_bag)
|
||||
yield option_bag
|
||||
if 'force_store_value' not in config_bag.properties:
|
||||
return
|
||||
values = config_bag.context.get_values()
|
||||
values = config_bag.context.cfgimpl_get_values()
|
||||
for option in self._cache_force_store_values:
|
||||
if option.impl_is_follower():
|
||||
leader = option.impl_get_leadership().get_leader()
|
||||
|
|
@ -151,7 +149,7 @@ class CacheOptionDescription(BaseOption):
|
|||
subpath = leader_option_bag.option.rootpath
|
||||
doption = option.to_dynoption(subpath,
|
||||
leader_option_bag.option.impl_getsuffix(),
|
||||
leader_option_bag.option.dyn_parent,
|
||||
leader_option_bag.option.ori_dyn,
|
||||
)
|
||||
else:
|
||||
doption = option
|
||||
|
|
@ -159,11 +157,12 @@ class CacheOptionDescription(BaseOption):
|
|||
for index in range(follower_len):
|
||||
if values.hasvalue(subpath, index):
|
||||
continue
|
||||
option_bag = OptionBag(doption,
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(doption,
|
||||
index,
|
||||
config_bag,
|
||||
properties=frozenset(),
|
||||
)
|
||||
option_bag.properties = frozenset()
|
||||
value = values.getvalue(option_bag)
|
||||
if value is None:
|
||||
continue
|
||||
|
|
@ -205,22 +204,19 @@ class OptionDescriptionWalk(CacheOptionDescription):
|
|||
return option
|
||||
# if dyn
|
||||
for child in self._children[1]:
|
||||
if not child.impl_is_dynoptiondescription():
|
||||
continue
|
||||
if child.impl_is_dynoptiondescription():
|
||||
cname = child.impl_getname()
|
||||
if not name.startswith(cname):
|
||||
continue
|
||||
if name.startswith(cname):
|
||||
for suffix in child.get_suffixes(config_bag):
|
||||
if name != cname + child.convert_suffix_to_path(suffix):
|
||||
continue
|
||||
if name == cname + child.convert_suffix_to_path(suffix):
|
||||
return child.to_dynoption(subpath,
|
||||
suffix,
|
||||
child,
|
||||
)
|
||||
child)
|
||||
if self.impl_get_group_type() == groups.root:
|
||||
raise AttributeError(_(f'unknown option "{name}" '
|
||||
'in root optiondescription'
|
||||
))
|
||||
else:
|
||||
raise AttributeError(_(f'unknown option "{name}" '
|
||||
f'in optiondescription "{self.impl_get_display_name()}"'
|
||||
))
|
||||
|
|
@ -230,7 +226,7 @@ class OptionDescriptionWalk(CacheOptionDescription):
|
|||
dyn: bool=True,
|
||||
) -> Union[BaseOption, SynDynOptionDescription]:
|
||||
if not dyn or config_bag is undefined or \
|
||||
config_bag.context.get_description() == self:
|
||||
config_bag.context.cfgimpl_get_description() == self:
|
||||
subpath = ''
|
||||
else:
|
||||
subpath = self.impl_getpath()
|
||||
|
|
@ -249,16 +245,14 @@ class OptionDescriptionWalk(CacheOptionDescription):
|
|||
bytype: Optional[BaseOption],
|
||||
byname: Optional[str],
|
||||
config_bag: ConfigBag,
|
||||
self_opt: BaseOption=None,
|
||||
) -> Iterator[Union[BaseOption, SynDynOptionDescription]]:
|
||||
self_opt: BaseOption=None) -> Iterator[Union[BaseOption, SynDynOptionDescription]]:
|
||||
if self_opt is None:
|
||||
self_opt = self
|
||||
for option in self_opt.get_children(config_bag):
|
||||
if option.impl_is_optiondescription():
|
||||
for subopt in option.get_children_recursively(bytype,
|
||||
byname,
|
||||
config_bag,
|
||||
):
|
||||
config_bag):
|
||||
yield subopt
|
||||
elif (byname is None or option.impl_getname() == byname) and \
|
||||
(bytype is None or isinstance(option, bytype)):
|
||||
|
|
@ -315,12 +309,6 @@ class OptionDescription(OptionDescriptionWalk):
|
|||
# the group_type is useful for filtering OptionDescriptions in a config
|
||||
self._group_type = groups.default
|
||||
|
||||
def _setsubdyn(self,
|
||||
subdyn,
|
||||
) -> None:
|
||||
raise ConfigError(_('cannot set optiondescription in a '
|
||||
'dynoptiondescription'))
|
||||
|
||||
def impl_is_optiondescription(self) -> bool:
|
||||
return True
|
||||
|
||||
|
|
|
|||
|
|
@ -20,7 +20,6 @@
|
|||
# ____________________________________________________________
|
||||
from typing import Any
|
||||
from .baseoption import BaseOption, valid_name
|
||||
from ..error import ConfigError
|
||||
from ..i18n import _
|
||||
|
||||
|
||||
|
|
@ -48,12 +47,6 @@ class SymLinkOption(BaseOption):
|
|||
) -> Any:
|
||||
return getattr(self._opt, name)
|
||||
|
||||
def _setsubdyn(self,
|
||||
subdyn,
|
||||
) -> None:
|
||||
raise ConfigError(_('cannot set symlinkoption in a '
|
||||
'dynoptiondescription'))
|
||||
|
||||
def impl_has_dependency(self,
|
||||
self_is_dep: bool=True) -> bool:
|
||||
"""If self_is_dep is True, it has dependency (self._opt), so return True
|
||||
|
|
|
|||
|
|
@ -29,25 +29,23 @@ class SynDynOption:
|
|||
__slots__ = ('rootpath',
|
||||
'opt',
|
||||
'suffix',
|
||||
'dyn_parent',
|
||||
'ori_dyn',
|
||||
'__weakref__')
|
||||
|
||||
def __init__(self,
|
||||
opt: BaseOption,
|
||||
rootpath: str,
|
||||
suffix: str,
|
||||
dyn_parent,
|
||||
) -> None:
|
||||
ori_dyn) -> None:
|
||||
self.opt = opt
|
||||
self.rootpath = rootpath
|
||||
self.suffix = suffix
|
||||
self.dyn_parent = dyn_parent
|
||||
self.ori_dyn = ori_dyn
|
||||
|
||||
def __getattr__(self,
|
||||
name: str) -> Any:
|
||||
return getattr(self.opt,
|
||||
name,
|
||||
)
|
||||
name)
|
||||
|
||||
def __eq__(self,
|
||||
left: BaseOption) -> bool:
|
||||
|
|
@ -58,21 +56,18 @@ class SynDynOption:
|
|||
self.suffix == left.suffix
|
||||
|
||||
def impl_getname(self) -> str:
|
||||
return self.opt.impl_getname() + self.dyn_parent.convert_suffix_to_path(self.suffix)
|
||||
return self.opt.impl_getname() + self.ori_dyn.convert_suffix_to_path(self.suffix)
|
||||
|
||||
def impl_get_display_name(self) -> str:
|
||||
return self.opt._get_display_name(dyn_name=self.impl_getname(),
|
||||
suffix=self.dyn_parent.convert_suffix_to_path(self.suffix),
|
||||
suffix=self.ori_dyn.convert_suffix_to_path(self.suffix),
|
||||
)
|
||||
|
||||
def impl_getsuffix(self) -> str:
|
||||
return self.suffix
|
||||
|
||||
def impl_getpath(self) -> str:
|
||||
path = self.impl_getname()
|
||||
if self.rootpath:
|
||||
path = f'{self.rootpath}.{path}'
|
||||
return path
|
||||
return self.rootpath + '.' + self.impl_getname()
|
||||
|
||||
def impl_is_dynsymlinkoption(self) -> bool:
|
||||
return True
|
||||
|
|
@ -83,5 +78,5 @@ class SynDynOption:
|
|||
rootpath = self.rootpath.rsplit('.', 1)[0]
|
||||
return leadership.to_dynoption(rootpath,
|
||||
self.suffix,
|
||||
self.dyn_parent,
|
||||
self.ori_dyn,
|
||||
)
|
||||
|
|
|
|||
|
|
@ -40,6 +40,9 @@ class SynDynOptionDescription:
|
|||
suffix: str,
|
||||
ori_dyn) -> None:
|
||||
self.opt = opt
|
||||
if rootpath is None:
|
||||
rootpath = ''
|
||||
assert isinstance(rootpath, str), 'rootpath must be a string, not {}'.format(type(rootpath))
|
||||
self.rootpath = rootpath
|
||||
self._suffix = suffix
|
||||
# For a Leadership inside a DynOptionDescription
|
||||
|
|
@ -59,8 +62,7 @@ class SynDynOptionDescription:
|
|||
def get_child(self,
|
||||
name: str,
|
||||
config_bag: ConfigBag,
|
||||
subpath: str,
|
||||
) -> BaseOption:
|
||||
subpath: str) -> BaseOption:
|
||||
suffix = self.ori_dyn.convert_suffix_to_path(self._suffix)
|
||||
if name.endswith(suffix):
|
||||
oname = name[:-len(suffix)]
|
||||
|
|
@ -103,20 +105,18 @@ class SynDynOptionDescription:
|
|||
bytype: Optional[BaseOption],
|
||||
byname: Optional[str],
|
||||
config_bag: ConfigBag,
|
||||
self_opt: BaseOption=None,
|
||||
) -> BaseOption:
|
||||
self_opt: BaseOption=None) -> BaseOption:
|
||||
for option in self.opt.get_children_recursively(bytype,
|
||||
byname,
|
||||
config_bag,
|
||||
self,
|
||||
):
|
||||
self):
|
||||
yield option
|
||||
|
||||
def impl_getpath(self) -> str:
|
||||
path = self.impl_getname()
|
||||
if self.rootpath:
|
||||
path = f'{self.rootpath}.{path}'
|
||||
return path
|
||||
rootpath = self.rootpath
|
||||
if rootpath != '':
|
||||
rootpath += '.'
|
||||
return rootpath + self.impl_getname()
|
||||
|
||||
def impl_get_display_name(self) -> str:
|
||||
return self.opt.impl_get_display_name() + str(self._suffix)
|
||||
|
|
@ -126,52 +126,44 @@ class SynDynLeadership(SynDynOptionDescription):
|
|||
def get_leader(self) -> SynDynOption:
|
||||
return self.opt.get_leader().to_dynoption(self.impl_getpath(),
|
||||
self._suffix,
|
||||
self.ori_dyn,
|
||||
)
|
||||
self.ori_dyn)
|
||||
|
||||
def get_followers(self) -> Iterator[SynDynOption]:
|
||||
subpath = self.impl_getpath()
|
||||
for follower in self.opt.get_followers():
|
||||
yield follower.to_dynoption(subpath,
|
||||
self._suffix,
|
||||
self.ori_dyn,
|
||||
)
|
||||
self.ori_dyn)
|
||||
|
||||
def reset_cache(self,
|
||||
path: str,
|
||||
config_bag: 'ConfigBag',
|
||||
resetted_opts: List[str],
|
||||
) -> None:
|
||||
resetted_opts: List[str]) -> None:
|
||||
leader = self.get_leader()
|
||||
followers = self.get_followers()
|
||||
self._reset_cache(path,
|
||||
leader,
|
||||
followers,
|
||||
config_bag,
|
||||
resetted_opts,
|
||||
)
|
||||
resetted_opts)
|
||||
|
||||
def pop(self,
|
||||
*args,
|
||||
**kwargs,
|
||||
) -> None:
|
||||
**kwargs) -> None:
|
||||
self.opt.pop(*args,
|
||||
followers=self.get_followers(),
|
||||
**kwargs,
|
||||
)
|
||||
**kwargs)
|
||||
|
||||
def follower_force_store_value(self,
|
||||
values,
|
||||
value,
|
||||
option_bag,
|
||||
owner,
|
||||
) -> None:
|
||||
owner) -> None:
|
||||
self.opt.follower_force_store_value(values,
|
||||
value,
|
||||
option_bag,
|
||||
owner,
|
||||
dyn=self,
|
||||
)
|
||||
dyn=self)
|
||||
|
||||
def impl_getsuffix(self) -> str:
|
||||
return self._suffix
|
||||
|
|
|
|||
|
|
@ -15,7 +15,6 @@
|
|||
# You should have received a copy of the GNU Lesser General Public License
|
||||
# along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
# ____________________________________________________________
|
||||
from typing import Union
|
||||
from itertools import chain
|
||||
from .error import PropertiesOptionError, ConstError, ConfigError, LeadershipError, display_list
|
||||
from .i18n import _
|
||||
|
|
@ -103,35 +102,19 @@ read_write
|
|||
you can get all variables not disabled and not hidden
|
||||
you can set all variables not frozen
|
||||
"""
|
||||
RO_APPEND = frozenset(['frozen',
|
||||
'disabled',
|
||||
'validator',
|
||||
'everything_frozen',
|
||||
'mandatory',
|
||||
'empty',
|
||||
'force_store_value',
|
||||
])
|
||||
RO_REMOVE = frozenset(['permissive',
|
||||
'hidden',
|
||||
])
|
||||
RW_APPEND = frozenset(['frozen',
|
||||
'disabled',
|
||||
'validator',
|
||||
'hidden',
|
||||
'force_store_value',
|
||||
])
|
||||
RW_REMOVE = frozenset(['permissive',
|
||||
'everything_frozen',
|
||||
'mandatory',
|
||||
'empty',
|
||||
])
|
||||
RO_APPEND = frozenset(['frozen', 'disabled', 'validator', 'everything_frozen',
|
||||
'mandatory', 'empty', 'force_store_value'])
|
||||
RO_REMOVE = frozenset(['permissive', 'hidden'])
|
||||
RW_APPEND = frozenset(['frozen', 'disabled', 'validator', 'hidden',
|
||||
'force_store_value'])
|
||||
RW_REMOVE = frozenset(['permissive', 'everything_frozen', 'mandatory',
|
||||
'empty'])
|
||||
|
||||
|
||||
FORBIDDEN_SET_PROPERTIES = frozenset(['force_store_value'])
|
||||
FORBIDDEN_SET_PERMISSIVES = frozenset(['force_default_on_freeze',
|
||||
'force_metaconfig_on_freeze',
|
||||
'force_store_value',
|
||||
])
|
||||
'force_store_value'])
|
||||
ALLOWED_LEADER_PROPERTIES = frozenset(['empty',
|
||||
'notempty',
|
||||
'notunique',
|
||||
|
|
@ -140,23 +123,11 @@ ALLOWED_LEADER_PROPERTIES = frozenset(['empty',
|
|||
'mandatory',
|
||||
'force_default_on_freeze',
|
||||
'force_metaconfig_on_freeze',
|
||||
'frozen',
|
||||
])
|
||||
'frozen'])
|
||||
|
||||
static_set = frozenset()
|
||||
|
||||
|
||||
# ____________________________________________________________
|
||||
class Undefined(object):
|
||||
def __str__(self): # pragma: no cover
|
||||
return 'Undefined'
|
||||
|
||||
__repr__ = __str__
|
||||
|
||||
|
||||
undefined = Undefined()
|
||||
|
||||
|
||||
class OptionBag:
|
||||
__slots__ = ('option', # current option
|
||||
'path',
|
||||
|
|
@ -164,42 +135,38 @@ class OptionBag:
|
|||
'config_bag',
|
||||
'ori_option', # original option (for example useful for symlinkoption)
|
||||
'properties', # properties of current option
|
||||
'properties_setted',
|
||||
'apply_requires', # apply requires or not for this option
|
||||
)
|
||||
|
||||
def __init__(self,
|
||||
def __init__(self):
|
||||
self.option = None
|
||||
|
||||
def set_option(self,
|
||||
option,
|
||||
index,
|
||||
config_bag,
|
||||
path=None,
|
||||
properties=undefined,
|
||||
ori_option=None,
|
||||
apply_requires=True,
|
||||
):
|
||||
self.index = index
|
||||
self.config_bag = config_bag
|
||||
self.option = option
|
||||
if ori_option is not None:
|
||||
self.ori_option = ori_option
|
||||
config_bag):
|
||||
if config_bag is undefined:
|
||||
self.path = path
|
||||
elif path:
|
||||
self.path = path
|
||||
elif option:
|
||||
self.path = None
|
||||
else:
|
||||
self.path = option.impl_getpath()
|
||||
if '.' not in self.path and option == config_bag.context.get_description():
|
||||
self.properties = None
|
||||
elif properties is undefined:
|
||||
self.properties = config_bag.context.get_settings().getproperties(self, apply_requires=apply_requires)
|
||||
if properties is not undefined:
|
||||
self.properties = properties
|
||||
self.index = index
|
||||
self.option = option
|
||||
self.config_bag = config_bag
|
||||
|
||||
def __getattr__(self, key):
|
||||
if key == 'ori_option':
|
||||
return self.option
|
||||
elif key == 'apply_requires':
|
||||
return True
|
||||
return undefined
|
||||
elif key == 'properties_setted':
|
||||
return False
|
||||
raise KeyError('unknown key "{}" for OptionBag'.format(key)) # pragma: no cover
|
||||
|
||||
def __setattr__(self, key, val):
|
||||
super().__setattr__(key, val)
|
||||
if key == 'properties':
|
||||
self.properties_setted = True
|
||||
|
||||
def __delattr__(self, key):
|
||||
if key in ['properties', 'permissives']:
|
||||
|
|
@ -211,13 +178,9 @@ class OptionBag:
|
|||
raise KeyError(_('cannot delete key "{}" for OptionBag').format(key)) # pragma: no cover
|
||||
|
||||
def copy(self):
|
||||
option_bag = OptionBag(None,
|
||||
None,
|
||||
None,
|
||||
)
|
||||
option_bag = OptionBag()
|
||||
for key in self.__slots__:
|
||||
if not hasattr(self, key):
|
||||
continue
|
||||
if hasattr(self, key):
|
||||
setattr(option_bag, key, getattr(self, key))
|
||||
return option_bag
|
||||
|
||||
|
|
@ -285,15 +248,13 @@ class _NameSpace(object):
|
|||
|
||||
def __setattr__(self,
|
||||
name,
|
||||
value,
|
||||
):
|
||||
value):
|
||||
if name in self.__dict__:
|
||||
raise ConstError(_("can't rebind {0}").format(name))
|
||||
self.__dict__[name] = value
|
||||
|
||||
def __delattr__(self,
|
||||
name,
|
||||
):
|
||||
name):
|
||||
raise ConstError(_("can't unbind {0}").format(name))
|
||||
|
||||
|
||||
|
|
@ -327,7 +288,7 @@ class GroupModule(_NameSpace):
|
|||
class OwnerModule(_NameSpace):
|
||||
"""emulates a module to manage unique owner names.
|
||||
|
||||
owners are living in `Config._value_owners`
|
||||
owners are living in `Config._cfgimpl_value_owners`
|
||||
"""
|
||||
class Owner(str):
|
||||
"""allowed owner names
|
||||
|
|
@ -381,6 +342,17 @@ owners.forced = owners.Owner('forced')
|
|||
forbidden_owners = (owners.default, owners.forced)
|
||||
|
||||
|
||||
# ____________________________________________________________
|
||||
class Undefined(object):
|
||||
def __str__(self): # pragma: no cover
|
||||
return 'Undefined'
|
||||
|
||||
__repr__ = __str__
|
||||
|
||||
|
||||
undefined = Undefined()
|
||||
|
||||
|
||||
# ____________________________________________________________
|
||||
class Settings(object):
|
||||
"``config.Config()``'s configuration options settings"
|
||||
|
|
@ -422,8 +394,7 @@ class Settings(object):
|
|||
None,
|
||||
{},
|
||||
{},
|
||||
'context_props',
|
||||
)
|
||||
'context_props')
|
||||
if not is_cached:
|
||||
props = self._properties.get(None, {}).get(None, self.default_properties)
|
||||
cache.setcache(None,
|
||||
|
|
@ -449,8 +420,7 @@ class Settings(object):
|
|||
option_bag,
|
||||
apply_requires=True,
|
||||
uncalculated=False,
|
||||
help_property=False,
|
||||
):
|
||||
help_property=False):
|
||||
"""
|
||||
"""
|
||||
option = option_bag.option
|
||||
|
|
@ -460,14 +430,13 @@ class Settings(object):
|
|||
path = option.impl_getpath()
|
||||
index = option_bag.index
|
||||
if apply_requires and not uncalculated and not help_property:
|
||||
cache = config_bag.context.properties_cache
|
||||
cache = config_bag.context._impl_properties_cache
|
||||
is_cached, props, validated = cache.getcache(path,
|
||||
config_bag.expiration_time,
|
||||
index,
|
||||
config_bag.properties,
|
||||
{},
|
||||
'self_props',
|
||||
)
|
||||
'self_props')
|
||||
else:
|
||||
is_cached = False
|
||||
if not is_cached:
|
||||
|
|
@ -577,12 +546,13 @@ class Settings(object):
|
|||
# set methods
|
||||
def set_context_properties(self, properties, context):
|
||||
self._properties.setdefault(None, {})[None] = properties
|
||||
context.reset_cache(None)
|
||||
context.cfgimpl_reset_cache(None)
|
||||
|
||||
def setproperties(self,
|
||||
option_bag,
|
||||
path,
|
||||
properties,
|
||||
):
|
||||
option_bag,
|
||||
context):
|
||||
"""save properties for specified path
|
||||
(never save properties if same has option properties)
|
||||
"""
|
||||
|
|
@ -602,9 +572,9 @@ class Settings(object):
|
|||
raise LeadershipError(_('a leader ({0}) cannot have '
|
||||
'"force_default_on_freeze" or "force_metaconfig_on_freeze" property without "frozen"'
|
||||
'').format(opt.impl_get_display_name()))
|
||||
self._properties.setdefault(option_bag.path, {})[option_bag.index] = properties
|
||||
self._properties.setdefault(path, {})[option_bag.index] = properties
|
||||
# values too because of follower values could have a PropertiesOptionError has value
|
||||
option_bag.config_bag.context.reset_cache(option_bag)
|
||||
context.cfgimpl_reset_cache(option_bag)
|
||||
option_bag.properties = properties
|
||||
|
||||
def set_context_permissives(self,
|
||||
|
|
@ -645,66 +615,59 @@ class Settings(object):
|
|||
' '.join(forbidden_permissives)))
|
||||
self._permissives.setdefault(path, {})[index] = permissives
|
||||
if option_bag is not None:
|
||||
option_bag.config_bag.context.reset_cache(option_bag)
|
||||
option_bag.config_bag.context.cfgimpl_reset_cache(option_bag)
|
||||
|
||||
#____________________________________________________________
|
||||
# reset methods
|
||||
def _get_path_index_config_option(self,
|
||||
bag: Union[OptionBag, ConfigBag],
|
||||
msg: str,
|
||||
):
|
||||
if isinstance(bag, ConfigBag):
|
||||
path = None
|
||||
index = None
|
||||
config_bag = bag
|
||||
option_bag = None
|
||||
else:
|
||||
assert not bag.option.impl_is_symlinkoption(), \
|
||||
_(msg).format(bag.option.impl_get_display_name())
|
||||
path = bag.path
|
||||
index = bag.index
|
||||
config_bag = bag.config_bag
|
||||
option_bag = bag
|
||||
return path, index, config_bag, option_bag
|
||||
|
||||
def reset(self,
|
||||
bag: Union[OptionBag, ConfigBag],
|
||||
):
|
||||
path, index, config_bag, option_bag = \
|
||||
self._get_path_index_config_option(bag,
|
||||
"can't reset properties to "
|
||||
"the symlinkoption \"{}\"",
|
||||
)
|
||||
option_bag,
|
||||
config_bag):
|
||||
if option_bag is None:
|
||||
opt = None
|
||||
path = None
|
||||
index = None
|
||||
else:
|
||||
opt = option_bag.option
|
||||
assert not opt.impl_is_symlinkoption(), _("can't reset properties to "
|
||||
"the symlinkoption \"{}\""
|
||||
"").format(opt.impl_get_display_name())
|
||||
path = option_bag.path
|
||||
index = option_bag.index
|
||||
if path in self._properties and index in self._properties[path]:
|
||||
del(self._properties[path][index])
|
||||
config_bag.context.reset_cache(option_bag)
|
||||
config_bag.context.cfgimpl_reset_cache(option_bag)
|
||||
|
||||
def reset_permissives(self,
|
||||
bag: Union[OptionBag, ConfigBag],
|
||||
):
|
||||
path, index, config_bag, option_bag = \
|
||||
self._get_path_index_config_option(bag,
|
||||
"can't reset permissives to "
|
||||
"the symlinkoption \"{}\"",
|
||||
)
|
||||
option_bag,
|
||||
config_bag):
|
||||
if option_bag is None:
|
||||
opt = None
|
||||
path = None
|
||||
index = None
|
||||
else:
|
||||
opt = option_bag.option
|
||||
assert not opt.impl_is_symlinkoption(), _("can't reset permissives to "
|
||||
"the symlinkoption \"{}\""
|
||||
"").format(opt.impl_get_display_name())
|
||||
index = option_bag.index
|
||||
path = option_bag.path
|
||||
if path in self._permissives and index in self._permissives[path]:
|
||||
del(self._permissives[path][index])
|
||||
config_bag.context.reset_cache(option_bag)
|
||||
config_bag.context.cfgimpl_reset_cache(option_bag)
|
||||
|
||||
#____________________________________________________________
|
||||
# validate properties
|
||||
def calc_raises_properties(self,
|
||||
option_bag,
|
||||
apply_requires=True,
|
||||
uncalculated=False,
|
||||
):
|
||||
if not uncalculated and apply_requires:
|
||||
uncalculated=False):
|
||||
if not uncalculated and apply_requires and option_bag.properties_setted:
|
||||
option_properties = option_bag.properties
|
||||
else:
|
||||
option_properties = self.getproperties(option_bag,
|
||||
apply_requires=apply_requires,
|
||||
uncalculated=uncalculated,
|
||||
)
|
||||
uncalculated=uncalculated)
|
||||
return self._calc_raises_properties(option_bag.config_bag.properties,
|
||||
option_bag.config_bag.permissives,
|
||||
option_properties)
|
||||
|
|
@ -723,8 +686,7 @@ class Settings(object):
|
|||
|
||||
def validate_properties(self,
|
||||
option_bag,
|
||||
need_help=True,
|
||||
):
|
||||
need_help=True):
|
||||
config_properties = option_bag.config_bag.properties
|
||||
if not config_properties or config_properties == frozenset(['cache']):
|
||||
# if no global property
|
||||
|
|
@ -733,13 +695,11 @@ class Settings(object):
|
|||
if properties != frozenset():
|
||||
if need_help:
|
||||
help_properties = dict(self.getproperties(option_bag,
|
||||
help_property=True,
|
||||
))
|
||||
help_property=True))
|
||||
calc_properties = []
|
||||
for property_ in self._calc_raises_properties(option_bag.config_bag.properties,
|
||||
option_bag.config_bag.permissives,
|
||||
set(help_properties.keys()),
|
||||
):
|
||||
set(help_properties.keys())):
|
||||
calc_properties.append(help_properties[property_])
|
||||
calc_properties = frozenset(calc_properties)
|
||||
else:
|
||||
|
|
@ -751,10 +711,9 @@ class Settings(object):
|
|||
|
||||
def validate_mandatory(self,
|
||||
value,
|
||||
option_bag,
|
||||
):
|
||||
option_bag):
|
||||
if 'mandatory' in option_bag.config_bag.properties:
|
||||
values = option_bag.config_bag.context.get_values()
|
||||
values = option_bag.config_bag.context.cfgimpl_get_values()
|
||||
if option_bag.option.impl_is_follower():
|
||||
force_allow_empty_list = True
|
||||
else:
|
||||
|
|
@ -764,21 +723,17 @@ class Settings(object):
|
|||
'mandatory' in option_bag.properties and values.isempty(option_bag.option,
|
||||
value,
|
||||
force_allow_empty_list=force_allow_empty_list,
|
||||
index=option_bag.index,
|
||||
):
|
||||
index=option_bag.index):
|
||||
raise PropertiesOptionError(option_bag,
|
||||
['mandatory'],
|
||||
self,
|
||||
)
|
||||
self)
|
||||
if 'empty' in option_bag.properties and values.isempty(option_bag.option,
|
||||
value,
|
||||
force_allow_empty_list=True,
|
||||
index=option_bag.index,
|
||||
):
|
||||
index=option_bag.index):
|
||||
raise PropertiesOptionError(option_bag,
|
||||
['empty'],
|
||||
self,
|
||||
)
|
||||
self)
|
||||
|
||||
def validate_frozen(self,
|
||||
option_bag):
|
||||
|
|
@ -797,8 +752,7 @@ class Settings(object):
|
|||
def _read(self,
|
||||
remove,
|
||||
append,
|
||||
config_bag,
|
||||
):
|
||||
config_bag):
|
||||
props = self._properties.get(None, {}).get(None, self.default_properties)
|
||||
modified = False
|
||||
if remove & props:
|
||||
|
|
@ -813,19 +767,15 @@ class Settings(object):
|
|||
)
|
||||
|
||||
def read_only(self,
|
||||
config_bag,
|
||||
):
|
||||
config_bag):
|
||||
"convenience method to freeze, hide and disable"
|
||||
self._read(self.ro_remove,
|
||||
self.ro_append,
|
||||
config_bag,
|
||||
)
|
||||
config_bag)
|
||||
|
||||
def read_write(self,
|
||||
config_bag,
|
||||
):
|
||||
config_bag):
|
||||
"convenience method to freeze, hide and disable"
|
||||
self._read(self.rw_remove,
|
||||
self.rw_append,
|
||||
config_bag,
|
||||
)
|
||||
config_bag)
|
||||
|
|
|
|||
|
|
@ -155,8 +155,7 @@ class Requires(object):
|
|||
childapi,
|
||||
path,
|
||||
form,
|
||||
current_action,
|
||||
):
|
||||
current_action):
|
||||
for requires in childapi.option.properties(uncalculated=True):
|
||||
if not isinstance(requires, str):
|
||||
option = requires.params.kwargs['condition'].option
|
||||
|
|
@ -373,8 +372,7 @@ class TiramisuDict:
|
|||
form,
|
||||
order,
|
||||
updates_status,
|
||||
init=False,
|
||||
):
|
||||
init=False):
|
||||
error = None
|
||||
if init:
|
||||
if form is not None:
|
||||
|
|
@ -401,25 +399,21 @@ class TiramisuDict:
|
|||
if form is not None:
|
||||
self.requires.add(path,
|
||||
childapi,
|
||||
form,
|
||||
)
|
||||
form)
|
||||
self.consistencies.add(path,
|
||||
childapi,
|
||||
form,
|
||||
)
|
||||
form)
|
||||
self.callbacks.add(path,
|
||||
childapi,
|
||||
schema,
|
||||
'force_store_value' in props_no_requires,
|
||||
)
|
||||
'force_store_value' in props_no_requires)
|
||||
childapi_option = childapi.option
|
||||
if model is not None and childapi.option.isoptiondescription() or not childapi_option.issymlinkoption():
|
||||
self.gen_model(model,
|
||||
childapi,
|
||||
path,
|
||||
leader_len,
|
||||
updates_status,
|
||||
)
|
||||
updates_status)
|
||||
if order is not None:
|
||||
order.append(path)
|
||||
if childapi.option.isoptiondescription():
|
||||
|
|
@ -440,8 +434,7 @@ class TiramisuDict:
|
|||
model,
|
||||
form,
|
||||
order,
|
||||
updates_status,
|
||||
)
|
||||
updates_status)
|
||||
else:
|
||||
child = childapi_option.get()
|
||||
childtype = child.__class__.__name__
|
||||
|
|
@ -476,16 +469,14 @@ class TiramisuDict:
|
|||
defaultmulti,
|
||||
is_multi,
|
||||
web_type,
|
||||
form,
|
||||
)
|
||||
form)
|
||||
if form is not None:
|
||||
self.gen_form(form,
|
||||
web_type,
|
||||
path,
|
||||
child,
|
||||
childapi_option,
|
||||
childtype,
|
||||
)
|
||||
childtype)
|
||||
if schema is not None:
|
||||
if web_type != 'symlink':
|
||||
schema[path]['title'] = childapi_option.description()
|
||||
|
|
@ -520,8 +511,7 @@ class TiramisuDict:
|
|||
defaultmulti,
|
||||
is_multi,
|
||||
web_type,
|
||||
form,
|
||||
):
|
||||
form):
|
||||
schema[path] = {'type': web_type}
|
||||
if childapi_option.issymlinkoption():
|
||||
sym_option = childapi_option.get()
|
||||
|
|
@ -558,8 +548,7 @@ class TiramisuDict:
|
|||
childapi,
|
||||
is_multi,
|
||||
path,
|
||||
props_no_requires,
|
||||
):
|
||||
props_no_requires):
|
||||
values = childapi.value.list()
|
||||
empty_is_required = not childapi.option.isfollower() and is_multi
|
||||
if '' not in values and ((empty_is_required and not 'empty' in props_no_requires) or \
|
||||
|
|
@ -573,8 +562,7 @@ class TiramisuDict:
|
|||
path,
|
||||
child,
|
||||
childapi_option,
|
||||
childtype,
|
||||
):
|
||||
childtype):
|
||||
obj_form = {}
|
||||
if path in form:
|
||||
obj_form.update(form[path])
|
||||
|
|
@ -614,13 +602,12 @@ class TiramisuDict:
|
|||
|
||||
def calc_raises_properties(self,
|
||||
obj,
|
||||
childapi,
|
||||
):
|
||||
old_properties = childapi._config_bag.properties
|
||||
config = childapi._config_bag.context
|
||||
settings = config.get_settings()
|
||||
childapi._config_bag.properties = self.config.property.get(default=True) # settings.get_context_properties(config._impl_properties_cache)
|
||||
childapi._config_bag.properties -= {'permissive'}
|
||||
childapi):
|
||||
old_properties = childapi._option_bag.config_bag.properties
|
||||
config = childapi._option_bag.config_bag.context
|
||||
settings = config.cfgimpl_get_settings()
|
||||
childapi._option_bag.config_bag.properties = self.config.property.get(default=True) # settings.get_context_properties(config._impl_properties_cache)
|
||||
childapi._option_bag.config_bag.properties -= {'permissive'}
|
||||
properties = childapi.property.get(only_raises=True,
|
||||
uncalculated=True)
|
||||
properties -= childapi.permissive.get()
|
||||
|
|
@ -631,13 +618,12 @@ class TiramisuDict:
|
|||
properties -= self.config.permissive.get()
|
||||
if properties:
|
||||
obj['hidden'] = True
|
||||
childapi._config_bag.properties = old_properties
|
||||
childapi._option_bag.config_bag.properties = old_properties
|
||||
|
||||
def _gen_model_properties(self,
|
||||
childapi,
|
||||
path,
|
||||
index,
|
||||
):
|
||||
index):
|
||||
isfollower = childapi.option.isfollower()
|
||||
props = set(childapi.property.get())
|
||||
obj = self.gen_properties(props,
|
||||
|
|
@ -685,8 +671,7 @@ class TiramisuDict:
|
|||
childapi,
|
||||
path,
|
||||
leader_len,
|
||||
updates_status,
|
||||
):
|
||||
updates_status):
|
||||
if childapi.option.isoptiondescription():
|
||||
props = set(childapi.property.get())
|
||||
obj = {}
|
||||
|
|
@ -702,21 +687,18 @@ class TiramisuDict:
|
|||
else:
|
||||
obj = self._gen_model_properties(childapi,
|
||||
path,
|
||||
None,
|
||||
)
|
||||
None)
|
||||
if childapi.option.isfollower():
|
||||
for index in range(leader_len):
|
||||
follower_childapi = self.config.unrestraint.option(path, index)
|
||||
sobj = self._gen_model_properties(follower_childapi,
|
||||
path,
|
||||
index,
|
||||
)
|
||||
index)
|
||||
self._get_model_value(follower_childapi,
|
||||
path,
|
||||
sobj,
|
||||
index,
|
||||
updates_status,
|
||||
)
|
||||
updates_status)
|
||||
if sobj:
|
||||
model.setdefault(path, {})[str(index)] = sobj
|
||||
else:
|
||||
|
|
@ -724,8 +706,7 @@ class TiramisuDict:
|
|||
path,
|
||||
obj,
|
||||
None,
|
||||
updates_status,
|
||||
)
|
||||
updates_status)
|
||||
if obj:
|
||||
if not childapi.option.isoptiondescription() and childapi.option.isfollower():
|
||||
model.setdefault(path, {})['null'] = obj
|
||||
|
|
@ -737,8 +718,7 @@ class TiramisuDict:
|
|||
path,
|
||||
obj,
|
||||
index,
|
||||
updates_status,
|
||||
):
|
||||
updates_status):
|
||||
if path in updates_status and index in updates_status[path]:
|
||||
value = childapi.value.get()
|
||||
self._get_value_with_exception(obj,
|
||||
|
|
@ -759,7 +739,7 @@ class TiramisuDict:
|
|||
value = self.config.unrestraint.option(path, index=index).value.get()
|
||||
except PropertiesOptionError as err:
|
||||
config_bag = self.config._config_bag
|
||||
settings = config_bag.context.get_settings()
|
||||
settings = config_bag.context.cfgimpl_get_settings()
|
||||
if settings._calc_raises_properties(config_bag.properties,
|
||||
config_bag.permissives,
|
||||
set(err.proptype)):
|
||||
|
|
@ -857,8 +837,7 @@ class TiramisuDict:
|
|||
def apply_updates(self,
|
||||
oripath,
|
||||
updates,
|
||||
model_ori,
|
||||
):
|
||||
model_ori):
|
||||
updates_status = {}
|
||||
for update in updates:
|
||||
path = update['name']
|
||||
|
|
@ -875,13 +854,11 @@ class TiramisuDict:
|
|||
self.mod_value(childapi,
|
||||
path,
|
||||
index,
|
||||
update.get('value', undefined),
|
||||
)
|
||||
update.get('value', undefined))
|
||||
elif update['action'] == 'delete':
|
||||
self.del_value(childapi,
|
||||
path,
|
||||
index,
|
||||
)
|
||||
index)
|
||||
elif update['action'] == 'add':
|
||||
if childapi_option.ismulti():
|
||||
self.add_value(childapi, path, update['value'])
|
||||
|
|
@ -896,22 +873,19 @@ class TiramisuDict:
|
|||
return updates_status
|
||||
|
||||
def set_updates(self,
|
||||
body,
|
||||
):
|
||||
body):
|
||||
root_path = self.root
|
||||
updates = body.get('updates', [])
|
||||
updates_status = self.apply_updates(root_path,
|
||||
updates,
|
||||
body.get('model'),
|
||||
)
|
||||
body.get('model'))
|
||||
if 'model' in body:
|
||||
order = []
|
||||
old_model = body['model']
|
||||
new_model = self.todict(order=order,
|
||||
build_schema=False,
|
||||
build_form=False,
|
||||
updates_status=updates_status,
|
||||
)
|
||||
updates_status=updates_status)
|
||||
values = {'updates': list_keys(old_model, new_model['model'], order, updates_status),
|
||||
'model': new_model['model']}
|
||||
else:
|
||||
|
|
@ -924,8 +898,7 @@ class TiramisuDict:
|
|||
build_model=True,
|
||||
build_form=True,
|
||||
order=None,
|
||||
updates_status={},
|
||||
):
|
||||
updates_status={}):
|
||||
rootpath = self.root
|
||||
if build_schema:
|
||||
schema = {}
|
||||
|
|
@ -947,8 +920,7 @@ class TiramisuDict:
|
|||
form,
|
||||
order,
|
||||
updates_status,
|
||||
init=True,
|
||||
)
|
||||
init=True)
|
||||
if build_form:
|
||||
for form_ in custom_form:
|
||||
if 'key' in form_:
|
||||
|
|
|
|||
|
|
@ -101,9 +101,9 @@ class Values:
|
|||
def force_to_metaconfig(self, option_bag):
|
||||
# force_metaconfig_on_freeze in config => to metaconfig
|
||||
# force_metaconfig_on_freeze in option + config is kernelconfig => to metaconfig
|
||||
settings = option_bag.config_bag.context.get_settings()
|
||||
settings = option_bag.config_bag.context.cfgimpl_get_settings()
|
||||
if 'force_metaconfig_on_freeze' in option_bag.properties:
|
||||
settings = option_bag.config_bag.context.get_settings()
|
||||
settings = option_bag.config_bag.context.cfgimpl_get_settings()
|
||||
if 'force_metaconfig_on_freeze' in option_bag.option.impl_getproperties() and \
|
||||
not settings._properties.get(option_bag.path, {}).get(None, frozenset()):
|
||||
# if force_metaconfig_on_freeze is only in option (not in config)
|
||||
|
|
@ -114,8 +114,7 @@ class Values:
|
|||
|
||||
def _do_value_list(self,
|
||||
value: Any,
|
||||
option_bag: OptionBag,
|
||||
):
|
||||
option_bag: OptionBag):
|
||||
ret = []
|
||||
for val in value:
|
||||
if isinstance(val, (list, tuple)):
|
||||
|
|
@ -181,7 +180,7 @@ class Values:
|
|||
moption_bag = self._get_modified_parent(option_bag)
|
||||
if moption_bag is not None:
|
||||
# retrieved value from parent config
|
||||
return moption_bag.config_bag.context.get_values().get_cached_value(moption_bag)
|
||||
return moption_bag.config_bag.context.cfgimpl_get_values().get_cached_value(moption_bag)
|
||||
|
||||
# now try to get default value:
|
||||
value = self.calc_value(option_bag,
|
||||
|
|
@ -227,7 +226,7 @@ class Values:
|
|||
# so do not invalidate cache
|
||||
return
|
||||
# calculated value is a new value, so reset cache
|
||||
option_bag.config_bag.context.reset_cache(option_bag)
|
||||
option_bag.config_bag.context.cfgimpl_reset_cache(option_bag)
|
||||
# and manage force_store_value
|
||||
self._set_force_value_suffix(option_bag)
|
||||
|
||||
|
|
@ -247,9 +246,9 @@ class Values:
|
|||
|
||||
#______________________________________________________________________
|
||||
# set value
|
||||
def set_value(self,
|
||||
option_bag,
|
||||
def setvalue(self,
|
||||
value,
|
||||
option_bag,
|
||||
):
|
||||
context = option_bag.config_bag.context
|
||||
owner = self.get_context_owner()
|
||||
|
|
@ -283,36 +282,30 @@ class Values:
|
|||
|
||||
def setvalue_validation(self,
|
||||
value,
|
||||
option_bag,
|
||||
):
|
||||
settings = option_bag.config_bag.context.get_settings()
|
||||
option_bag):
|
||||
settings = option_bag.config_bag.context.cfgimpl_get_settings()
|
||||
# First validate properties with this value
|
||||
opt = option_bag.option
|
||||
settings.validate_frozen(option_bag)
|
||||
val = self.calc_value(option_bag,
|
||||
value,
|
||||
False,)
|
||||
val = self.calc_value(option_bag, value, False)
|
||||
settings.validate_mandatory(val,
|
||||
option_bag,
|
||||
)
|
||||
option_bag)
|
||||
# Value must be valid for option
|
||||
opt.impl_validate(val,
|
||||
option_bag,
|
||||
check_error=True,
|
||||
)
|
||||
check_error=True)
|
||||
if 'warnings' in option_bag.config_bag.properties:
|
||||
# No error found so emit warnings
|
||||
opt.impl_validate(value,
|
||||
option_bag,
|
||||
check_error=False,
|
||||
)
|
||||
check_error=False)
|
||||
|
||||
def _setvalue(self,
|
||||
option_bag: OptionBag,
|
||||
value: Any,
|
||||
owner: str,
|
||||
) -> None:
|
||||
option_bag.config_bag.context.reset_cache(option_bag)
|
||||
option_bag.config_bag.context.cfgimpl_reset_cache(option_bag)
|
||||
self.set_storage_value(option_bag.path,
|
||||
option_bag.index,
|
||||
value,
|
||||
|
|
@ -350,7 +343,7 @@ class Values:
|
|||
if not force_store_options:
|
||||
continue
|
||||
rootpath = option.impl_getpath()
|
||||
settings = option_bag.config_bag.context.get_settings()
|
||||
settings = option_bag.config_bag.context.cfgimpl_get_settings()
|
||||
for suffix in option.get_suffixes(option_bag.config_bag):
|
||||
for coption in force_store_options:
|
||||
subpaths = [rootpath] + coption.impl_getpath()[len(rootpath) + 1:].split('.')[:-1]
|
||||
|
|
@ -362,24 +355,26 @@ class Values:
|
|||
)
|
||||
if coption.impl_is_follower():
|
||||
leader = coption.impl_get_leadership().get_leader()
|
||||
loption_bag = OptionBag(leader,
|
||||
loption_bag = OptionBag()
|
||||
loption_bag.set_option(leader,
|
||||
None,
|
||||
option_bag.config_bag,
|
||||
properties=frozenset(),
|
||||
)
|
||||
loption_bag.properties = frozenset()
|
||||
indexes = range(len(self.getvalue(loption_bag)))
|
||||
else:
|
||||
indexes = [None]
|
||||
for index in indexes:
|
||||
coption_bag = OptionBag(doption,
|
||||
coption_bag = OptionBag()
|
||||
coption_bag.set_option(doption,
|
||||
index,
|
||||
option_bag.config_bag,
|
||||
)
|
||||
coption_bag.properties = settings.getproperties(coption_bag)
|
||||
self._values.setdefault(coption_bag.path, {})[index] = [self.getvalue(coption_bag), owners.forced]
|
||||
|
||||
def _get_modified_parent(self,
|
||||
option_bag: OptionBag,
|
||||
) -> Optional[OptionBag]:
|
||||
option_bag: OptionBag) -> Optional[OptionBag]:
|
||||
""" Search in differents parents a Config with a modified value
|
||||
If not found, return None
|
||||
For follower option, return the Config where leader is modified
|
||||
|
|
@ -398,14 +393,13 @@ class Values:
|
|||
# remove force_metaconfig_on_freeze only if option in metaconfig
|
||||
# hasn't force_metaconfig_on_freeze properties
|
||||
ori_properties = doption_bag.properties
|
||||
doption_bag.properties = doption_bag.config_bag.context.get_settings().getproperties(doption_bag)
|
||||
doption_bag.properties = doption_bag.config_bag.context.cfgimpl_get_settings().getproperties(doption_bag)
|
||||
if not self.force_to_metaconfig(doption_bag):
|
||||
doption_bag.properties = ori_properties - {'force_metaconfig_on_freeze'}
|
||||
else:
|
||||
doption_bag.properties = ori_properties
|
||||
parent_owner = parent.get_values().getowner(doption_bag,
|
||||
only_default=True,
|
||||
)
|
||||
parent_owner = parent.cfgimpl_get_values().getowner(doption_bag,
|
||||
only_default=True)
|
||||
if parent_owner != owners.default:
|
||||
return doption_bag
|
||||
|
||||
|
|
@ -439,8 +433,7 @@ class Values:
|
|||
def getowner(self,
|
||||
option_bag,
|
||||
validate_meta=True,
|
||||
only_default=False,
|
||||
):
|
||||
only_default=False):
|
||||
"""
|
||||
retrieves the option's owner
|
||||
|
||||
|
|
@ -456,7 +449,7 @@ class Values:
|
|||
opt = opt.impl_getopt()
|
||||
option_bag.option = opt
|
||||
option_bag.path = opt.impl_getpath()
|
||||
settings = context.get_settings()
|
||||
settings = context.cfgimpl_get_settings()
|
||||
settings.validate_properties(option_bag)
|
||||
if 'frozen' in option_bag.properties and \
|
||||
'force_default_on_freeze' in option_bag.properties:
|
||||
|
|
@ -473,16 +466,15 @@ class Values:
|
|||
'frozen' in option_bag.properties and 'force_metaconfig_on_freeze' in option_bag.properties):
|
||||
moption_bag = self._get_modified_parent(option_bag)
|
||||
if moption_bag is not None:
|
||||
owner = moption_bag.config_bag.context.get_values().getowner(moption_bag,
|
||||
only_default=only_default,
|
||||
)
|
||||
owner = moption_bag.config_bag.context.cfgimpl_get_values().getowner(moption_bag,
|
||||
only_default=only_default)
|
||||
elif 'force_metaconfig_on_freeze' in option_bag.properties:
|
||||
return owners.default
|
||||
return owner
|
||||
|
||||
def set_owner(self,
|
||||
option_bag,
|
||||
def setowner(self,
|
||||
owner,
|
||||
option_bag,
|
||||
):
|
||||
"""
|
||||
sets a owner to an option
|
||||
|
|
@ -500,7 +492,7 @@ class Values:
|
|||
if not self.hasvalue(option_bag.path, option_bag.index):
|
||||
raise ConfigError(_('no value for {0} cannot change owner to {1}'
|
||||
'').format(option_bag.path, owner))
|
||||
option_bag.config_bag.context.get_settings().validate_frozen(option_bag)
|
||||
option_bag.config_bag.context.cfgimpl_get_settings().validate_frozen(option_bag)
|
||||
self._values[option_bag.path][option_bag.index][1] = owner
|
||||
#______________________________________________________________________
|
||||
# reset
|
||||
|
|
@ -518,7 +510,7 @@ class Values:
|
|||
config_bag.context = fake_context
|
||||
soption_bag = option_bag.copy()
|
||||
soption_bag.config_bag = config_bag
|
||||
fake_value = fake_context.get_values()
|
||||
fake_value = fake_context.cfgimpl_get_values()
|
||||
fake_value.reset(soption_bag)
|
||||
soption_bag.config_bag.properties = option_bag.config_bag.properties
|
||||
value = fake_value.getdefaultvalue(soption_bag)
|
||||
|
|
@ -541,7 +533,7 @@ class Values:
|
|||
value = None
|
||||
if option_bag.path in self._values:
|
||||
del self._values[option_bag.path]
|
||||
context.reset_cache(option_bag)
|
||||
context.cfgimpl_reset_cache(option_bag)
|
||||
if 'force_store_value' in setting_properties and option_bag.option.impl_is_leader():
|
||||
if value is None:
|
||||
value = self.getdefaultvalue(option_bag)
|
||||
|
|
@ -564,7 +556,7 @@ class Values:
|
|||
setting_properties = option_bag.config_bag.properties
|
||||
if 'validator' in setting_properties:
|
||||
fake_context = context._gen_fake_values()
|
||||
fake_value = fake_context.get_values()
|
||||
fake_value = fake_context.cfgimpl_get_values()
|
||||
config_bag = option_bag.config_bag.copy()
|
||||
config_bag.remove_validation()
|
||||
config_bag.context = fake_context
|
||||
|
|
@ -585,7 +577,7 @@ class Values:
|
|||
self.resetvalue_index(option_bag.path,
|
||||
option_bag.index,
|
||||
)
|
||||
context.reset_cache(option_bag)
|
||||
context.cfgimpl_reset_cache(option_bag)
|
||||
|
||||
def resetvalue_index(self,
|
||||
path,
|
||||
|
|
@ -595,10 +587,9 @@ class Values:
|
|||
del self._values[path][index]
|
||||
|
||||
def reset_leadership(self,
|
||||
option_bag: OptionBag,
|
||||
leadership_option_bag: OptionBag,
|
||||
index: int,
|
||||
):
|
||||
index,
|
||||
option_bag,
|
||||
subconfig):
|
||||
current_value = self.get_cached_value(option_bag)
|
||||
length = len(current_value)
|
||||
if index >= length:
|
||||
|
|
@ -607,13 +598,12 @@ class Values:
|
|||
length,
|
||||
option_bag.option.impl_get_display_name()))
|
||||
current_value.pop(index)
|
||||
leadership_option_bag.option.pop(self,
|
||||
subconfig.cfgimpl_get_description().pop(self,
|
||||
index,
|
||||
option_bag)
|
||||
self.setvalue(current_value,
|
||||
option_bag,
|
||||
)
|
||||
self.set_value(option_bag,
|
||||
current_value,
|
||||
)
|
||||
|
||||
#______________________________________________________________________
|
||||
# information
|
||||
|
|
@ -636,7 +626,7 @@ class Values:
|
|||
self._informations.setdefault(path, {})[key] = value
|
||||
if path is not None:
|
||||
for option in option_bag.option.get_dependencies_information(itself=True):
|
||||
config_bag.context.reset_cache(option_bag)
|
||||
config_bag.context.cfgimpl_reset_cache(option_bag)
|
||||
|
||||
def get_information(self,
|
||||
config_bag,
|
||||
|
|
@ -676,6 +666,95 @@ class Values:
|
|||
):
|
||||
return list(self._informations.get(path, {}).keys())
|
||||
|
||||
#______________________________________________________________________
|
||||
# mandatory warnings
|
||||
def _mandatory_warnings(self,
|
||||
context,
|
||||
config_bag,
|
||||
description,
|
||||
currpath,
|
||||
subconfig,
|
||||
od_config_bag):
|
||||
settings = context.cfgimpl_get_settings()
|
||||
for option in description.get_children(config_bag):
|
||||
name = option.impl_getname()
|
||||
if option.impl_is_optiondescription():
|
||||
try:
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(option,
|
||||
None,
|
||||
od_config_bag)
|
||||
option_bag.properties = settings.getproperties(option_bag)
|
||||
|
||||
subsubconfig = subconfig.get_subconfig(option_bag)
|
||||
except PropertiesOptionError as err:
|
||||
pass
|
||||
else:
|
||||
for option in self._mandatory_warnings(context,
|
||||
config_bag,
|
||||
option,
|
||||
currpath + [name],
|
||||
subsubconfig,
|
||||
od_config_bag):
|
||||
yield option
|
||||
elif not option.impl_is_symlinkoption():
|
||||
# don't verifying symlink
|
||||
try:
|
||||
if not option.impl_is_follower():
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(option,
|
||||
None,
|
||||
config_bag)
|
||||
option_bag.properties = settings.getproperties(option_bag)
|
||||
if 'mandatory' in option_bag.properties or 'empty' in option_bag.properties:
|
||||
subconfig.getattr(name,
|
||||
option_bag)
|
||||
else:
|
||||
for index in range(subconfig.cfgimpl_get_length()):
|
||||
option_bag = OptionBag()
|
||||
option_bag.set_option(option,
|
||||
index,
|
||||
config_bag)
|
||||
option_bag.properties = settings.getproperties(option_bag)
|
||||
if 'mandatory' in option_bag.properties or 'empty' in option_bag.properties:
|
||||
subconfig.getattr(name,
|
||||
option_bag)
|
||||
except PropertiesOptionError as err:
|
||||
if err.proptype in (['mandatory'], ['empty']):
|
||||
yield option.impl_getpath()
|
||||
except ConfigError:
|
||||
pass
|
||||
|
||||
def mandatory_warnings(self,
|
||||
config_bag):
|
||||
"""convenience function to trace Options that are mandatory and
|
||||
where no value has been set
|
||||
|
||||
:returns: generator of mandatory Option's path
|
||||
"""
|
||||
context = config_bag.context
|
||||
# copy
|
||||
od_setting_properties = config_bag.properties - {'mandatory', 'empty'}
|
||||
setting_properties = set(config_bag.properties) - {'warnings'}
|
||||
setting_properties.update(['mandatory', 'empty'])
|
||||
nconfig_bag = ConfigBag(context=config_bag.context,
|
||||
properties=frozenset(setting_properties),
|
||||
permissives=config_bag.permissives)
|
||||
nconfig_bag.set_permissive()
|
||||
od_config_bag = ConfigBag(context=nconfig_bag.context,
|
||||
properties=frozenset(od_setting_properties),
|
||||
permissives=nconfig_bag.permissives)
|
||||
od_config_bag.set_permissive()
|
||||
|
||||
descr = context.cfgimpl_get_description()
|
||||
for option in self._mandatory_warnings(context,
|
||||
nconfig_bag,
|
||||
descr,
|
||||
[],
|
||||
context,
|
||||
od_config_bag):
|
||||
yield option
|
||||
|
||||
#____________________________________________________________
|
||||
# default owner methods
|
||||
def set_context_owner(self, owner):
|
||||
|
|
|
|||
Loading…
Reference in a new issue