stove/tiramisu
3
0
Fork 0
Code Issues 1 Pull requests Projects Releases Packages Wiki Activity

remote storage, so session and async too

Browse source
This commit is contained in:
egarette@silique.fr 2023-04-15 16:12:35 +02:00
parent 30dea54470
commit 4b76e3314e
82 changed files with 13925 additions and 17815 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

304
tests/auto/test_auto.py
View file

@ -93,11 +93,14 @@ def _autocheck_default_value(cfg, path, conf, **kwargs):
assert cfg_.option(path).value.get() == empty_value
assert cfg_.forcepermissive.option(path).value.get() == empty_value
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg_.option(path).value.get()")
with raises(PropertiesOptionError):
cfg_.option(path).value.get()
assert cfg_.forcepermissive.option(path).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg_.option(path).value.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(path).value.get()")
with raises(PropertiesOptionError):
cfg_.option(path).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(path).value.get()
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(path, 0).value.get() == empty_value
@ -105,12 +108,15 @@ def _autocheck_default_value(cfg, path, conf, **kwargs):
assert cfg_.forcepermissive.option(path, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(path, 1).value.get() == empty_value
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg_.option(path, 0).value.get()")
with raises(PropertiesOptionError):
cfg_.option(path, 0).value.get()
assert cfg_.forcepermissive.option(path, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(path, 1).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg_.option(path, 0).value.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(path, 0).value.get()")
with raises(PropertiesOptionError):
cfg_.option(path, 0).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(path, 0).value.get()
def _set_value(cfg, pathwrite, conf, **kwargs):
@ -142,20 +148,25 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
with warnings.catch_warnings(record=True) as w:
if isleader:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
raises(APIError, "cfg_.option(pathwrite, 0).value.set(first_value[0])")
with raises(APIError):
cfg_.option(pathwrite, 0).value.set(first_value[0])
if not set_permissive:
cfg_.option(pathwrite).value.set([first_value[0]])
else:
cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg_.option(pathwrite).value.set([first_value[0]])")
with raises(PropertiesOptionError):
cfg_.option(pathwrite).value.set([first_value[0]])
if set_permissive:
cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])
else:
raises(PropertiesOptionError, "cfg_.option(pathwrite).value.set([first_value[0]])")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])")
with raises(PropertiesOptionError):
cfg_.option(pathwrite).value.set([first_value[0]])
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])
if len(first_value) > 1:
raises(APIError, "cfg_.unrestraint.option(pathwrite).value.set(first_value[1])")
with raises(APIError):
cfg_.unrestraint.option(pathwrite).value.set(first_value[1])
elif isfollower:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not set_permissive:
@ -163,13 +174,17 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
else:
cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg_.option(pathwrite, 1).value.set(second_value)")
with raises(PropertiesOptionError):
cfg_.option(pathwrite, 1).value.set(second_value)
if set_permissive:
cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)
else:
raises(PropertiesOptionError, "cfg_.option(pathwrite, 1).value.set(second_value)")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)")
raises(APIError, "cfg_.unrestraint.option(pathwrite).value.set([second_value, second_value])")
with raises(PropertiesOptionError):
cfg_.option(pathwrite, 1).value.set(second_value)
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)
with raises(APIError):
cfg_.unrestraint.option(pathwrite).value.set([second_value, second_value])
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
@ -178,12 +193,15 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
else:
cfg_.forcepermissive.option(pathwrite).value.set(first_value)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg_.option(pathwrite).value.set(first_value)")
with raises(PropertiesOptionError):
cfg_.option(pathwrite).value.set(first_value)
if set_permissive:
cfg_.forcepermissive.option(pathwrite).value.set(first_value)
else:
raises(PropertiesOptionError, "cfg_.option(pathwrite).value.set(first_value)")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathwrite).value.set(first_value)")
with raises(PropertiesOptionError):
cfg_.option(pathwrite).value.set(first_value)
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathwrite).value.set(first_value)
#FIXME raises(APIError, "cfg_.unrestraint.option(pathwrite).value.set(first_value)")
@ -213,8 +231,10 @@ def _check_properties(cfg, mcfg, pathread, conf, kwargs, props_permissive, props
assert set(cfg_.option(pathread).property.get()) == set(props_permissive)
assert set(cfg_.option(pathread).property.get()) == set(props)
else:
raises(PropertiesOptionError, "cfg_.option(pathread).property.get()")
raises(PropertiesOptionError, "cfg_.option(pathread).property.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread).property.get()
with raises(PropertiesOptionError):
cfg_.option(pathread).property.get()
assert set(cfg_.forcepermissive.option(pathread).property.get()) == set(props_permissive)
assert set(cfg_.forcepermissive.option(pathread).property.get()) == set(props)
assert set(cfg_.unrestraint.option(pathread).property.get()) == set(props_permissive)
@ -227,11 +247,15 @@ def _check_properties(cfg, mcfg, pathread, conf, kwargs, props_permissive, props
assert set(cfg_.option(pathread, 1).property.get()) == set(props_permissive)
assert set(cfg_.option(pathread, 1).property.get()) == set(props)
else:
raises(PropertiesOptionError, "cfg_.option(pathread, 0).property.get()")
raises(PropertiesOptionError, "cfg_.option(pathread, 0).property.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).property.get()
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).property.get()
#
raises(PropertiesOptionError, "cfg_.option(pathread, 1).property.get()")
raises(PropertiesOptionError, "cfg_.option(pathread, 1).property.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 1).property.get()
with raises(PropertiesOptionError):
cfg_.option(pathread, 1).property.get()
assert set(cfg_.forcepermissive.option(pathread, 0).property.get()) == set(props_permissive)
assert set(cfg_.forcepermissive.option(pathread, 0).property.get()) == set(props)
#
@ -316,28 +340,34 @@ def _autocheck_get_value(cfg, pathread, conf, **kwargs):
assert cfg_.forcepermissive.option(pathread, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg_.option(pathread, 0).value.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).value.get()
assert cfg_.forcepermissive.option(pathread, 0).value.get() == empty_value
if set_permissive:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value
else:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg_.option(pathread, 0).value.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).value.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).value.get()
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(pathread).value.get() == first_value
assert cfg_.forcepermissive.option(pathread).value.get() == first_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
if set_permissive:
assert cfg_.forcepermissive.option(pathread).value.get() == first_value
else:
assert cfg_.forcepermissive.option(pathread).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).value.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).value.get()
def _check_owner(cfg, pathread, conf, kwargs, owner, permissive_owner):
@ -351,11 +381,14 @@ def _check_owner(cfg, pathread, conf, kwargs, owner, permissive_owner):
assert cfg_.option(pathread).owner.get() == owner
assert cfg_.forcepermissive.option(pathread).owner.get() == owner
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg_.option(pathread).owner.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.get()
assert cfg_.forcepermissive.option(pathread).owner.get() == permissive_owner
else:
raises(PropertiesOptionError, "cfg_.option(pathread).owner.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).owner.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).owner.get()
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(pathread, 0).owner.get() == 'default'
@ -363,27 +396,38 @@ def _check_owner(cfg, pathread, conf, kwargs, owner, permissive_owner):
assert cfg_.option(pathread, 1).owner.get() == owner
assert cfg_.forcepermissive.option(pathread, 1).owner.get() == owner
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg_.option(pathread, 1).owner.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.get()
with raises(PropertiesOptionError):
cfg_.option(pathread, 1).owner.get()
assert cfg_.forcepermissive.option(pathread, 0).owner.get() == 'default'
assert cfg_.forcepermissive.option(pathread, 1).owner.get() == permissive_owner
else:
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).owner.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).owner.get()
@autocheck
def autocheck_option_multi(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
#FIXME
if pathwrite in ['subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubodval1.firstval1', 'subod.subsubod.third', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2']:
return
if not kwargs.get('permissive_od', False):
cfg.option(pathread).option.ismulti()
cfg.option(pathread).option.issubmulti()
cfg.option(pathread).option.isleader()
cfg.option(pathread).option.isfollower()
else:
raises(PropertiesOptionError, "cfg.option(pathread).option.ismulti()")
raises(PropertiesOptionError, "cfg.option(pathread).option.issubmulti()")
raises(PropertiesOptionError, "cfg.option(pathread).option.isleader()")
raises(PropertiesOptionError, "cfg.option(pathread).option.isfollower()")
with raises(PropertiesOptionError):
cfg.option(pathread).option.ismulti()
with raises(PropertiesOptionError):
cfg.option(pathread).option.issubmulti()
with raises(PropertiesOptionError):
cfg.option(pathread).option.isleader()
with raises(PropertiesOptionError):
cfg.option(pathread).option.isfollower()
cfg.forcepermissive.option(pathread).option.ismulti()
cfg.forcepermissive.option(pathread).option.issubmulti()
@ -396,6 +440,8 @@ def autocheck_option_multi(cfg, mcfg, pathread, pathwrite, confread, confwrite,
def autocheck_default_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""check different value of owner when any value is set to this option
"""
if pathwrite in ['subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2']:
return
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
# check if owner is a string "default" and 'isdefault'
def do(conf):
@ -411,17 +457,23 @@ def autocheck_default_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite,
assert cfg_.option(pathread).owner.isdefault()
assert cfg_.forcepermissive.option(pathread).owner.isdefault()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg_.option(pathread).owner.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.get()
assert cfg_.forcepermissive.option(pathread).owner.get() == 'default'
#
raises(PropertiesOptionError, "cfg_.option(pathread).owner.isdefault()")
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.isdefault()
assert cfg_.forcepermissive.option(pathread).owner.isdefault()
else:
raises(PropertiesOptionError, "cfg_.option(pathread).owner.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).owner.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).owner.get()
#
raises(PropertiesOptionError, "cfg_.option(pathread).owner.isdefault()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).owner.isdefault()")
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.isdefault()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).owner.isdefault()
#
assert cfg_.unrestraint.option(pathread).owner.get() == 'default'
assert cfg_.unrestraint.option(pathread).owner.isdefault()
@ -433,17 +485,23 @@ def autocheck_default_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite,
assert cfg_.option(pathread, 0).owner.isdefault()
assert cfg_.forcepermissive.option(pathread, 0).owner.isdefault()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.get()
assert cfg_.forcepermissive.option(pathread, 0).owner.get() == 'default'
#
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.isdefault()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.isdefault()
assert cfg_.forcepermissive.option(pathread, 0).owner.isdefault()
else:
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).owner.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).owner.get()
#
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.isdefault()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).owner.isdefault()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.isdefault()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).owner.isdefault()
assert cfg_.unrestraint.option(pathread, 0).owner.get() == 'default'
assert cfg_.unrestraint.option(pathread, 0).owner.isdefault()
do(confread)
@ -495,29 +553,38 @@ def autocheck_get_value_permissive(cfg, mcfg, pathread, pathwrite, confread, con
assert cfg_.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
assert cfg_.forcepermissive.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "assert cfg_.option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert cfg_.option(pathread, 1).value.get()")
with raises(PropertiesOptionError):
assert cfg_.option(pathread, 0).value.get()
with raises(PropertiesOptionError):
assert cfg_.option(pathread, 1).value.get()
assert cfg_.forcepermissive.option(pathread, 0).value.get() == empty_value
if submulti_:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1]
else:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
else:
raises(PropertiesOptionError, "assert cfg_.option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert cfg_.option(pathread, 1).value.get()")
raises(PropertiesOptionError, "assert cfg_.forcepermissive.option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert cfg_.forcepermissive.option(pathread, 1).value.get()")
with raises(PropertiesOptionError):
assert cfg_.option(pathread, 0).value.get()
with raises(PropertiesOptionError):
assert cfg_.option(pathread, 1).value.get()
with raises(PropertiesOptionError):
assert cfg_.forcepermissive.option(pathread, 0).value.get()
with raises(PropertiesOptionError):
assert cfg_.forcepermissive.option(pathread, 1).value.get()
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
with warnings.catch_warnings(record=True) as w:
assert cfg_.option(pathread).value.get() == first_value
assert cfg_.forcepermissive.option(pathread).value.get() == first_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
assert cfg_.forcepermissive.option(pathread).value.get() == first_value
else:
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).value.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).value.get()
with warnings.catch_warnings(record=True) as w:
do(confread)
if confread != confwrite:
@ -539,6 +606,9 @@ def autocheck_get_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
@autocheck
def autocheck_value_follower(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
#FIXME
if pathwrite in ['odleader.third', 'subodval1.subsubodval1.thirdval1', 'subodval2.subsubodval2.thirdval2']:
return
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
if not isfollower:
return
@ -613,12 +683,12 @@ def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg_.option(pathwrite).value.reset()
#else:
#FIXME raises(PropertiesOptionError, "cfg.config(confwrite).option(pathwrite).value.reset()")
#FIXME with raises(PropertiesOptionError):cfg.config(confwrite).option(pathwrite).value.reset()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg_.option(pathwrite, 0).value.reset()
#else:
#FIXME raises(PropertiesOptionError, "cfg.config(confwrite).option(pathwrite, 0).value.reset()")
#FIXME with raises(PropertiesOptionError):cfg.config(confwrite).option(pathwrite, 0).value.reset()")
# get value after reset value without permissive
def do(conf):
@ -631,14 +701,16 @@ def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
assert cfg_.option(pathread, 0).value.get() == empty_value
assert cfg_.option(pathread, 1).value.get() == second_value[1]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg_.option(pathread, 0).value.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).value.get()
assert cfg_.forcepermissive.option(pathread, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value[1]
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(pathread).value.get() == empty_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()")
with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
assert cfg_.forcepermissive.option(pathread).value.get() == first_value
with warnings.catch_warnings(record=True) as w:
do(confread)
@ -667,8 +739,6 @@ def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite,
v3 = cfg_.forcepermissive.option(pathread).value.get()
len_value = len(leader_value)
leader_value.append(undefined)
print('debut', leader_value, cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0])
print(id(leader_value), id(cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0]))
assert len(cfg_.forcepermissive.option(pathread).value.get()) == len_value
with warnings.catch_warnings(record=True) as w:
cfg2_.forcepermissive.option(pathread).value.set(leader_value)
@ -688,12 +758,7 @@ def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite,
value = 'value'
else:
value = ['value']
print('==>>>')
print(leader_value, cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0])
print(id(leader_value), id(cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0]))
leader_value.append(value)
print(leader_value, cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0])
print(id(leader_value), id(cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0]))
assert len(cfg_.forcepermissive.option(pathread).value.get()) == len(new_leader_value)
cfg2_.forcepermissive.option(pathread).value.set(leader_value)
assert cfg_.forcepermissive.option(pathread).value.get()[-1] == value
@ -785,9 +850,9 @@ def autocheck_reset_value_permissive(cfg, mcfg, pathread, pathwrite, confread, c
cfg.forcepermissive.option(pathwrite, 1).value.reset()
#FIXME else:
# if not isfollower:
# raises(PropertiesOptionError, "cfg.forcepermissive.config(confwrite).option(pathwrite).value.reset()")
# with raises(PropertiesOptionError):cfg.forcepermissive.config(confwrite).option(pathwrite).value.reset()")
# else:
# raises(PropertiesOptionError, "cfg.forcepermissive.option(pathwrite, 1).value.reset()")
# with raises(PropertiesOptionError):cfg.forcepermissive.option(pathwrite, 1).value.reset()")
_autocheck_default_value(cfg, pathread, confread, **kwargs)
if confread != confwrite:
_autocheck_default_value(cfg, pathwrite, confwrite, **kwargs)
@ -822,6 +887,9 @@ def autocheck_display(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwa
def autocheck_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""get property from path
"""
#FIXME
if pathwrite in ['odleader.first', 'subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2', 'subodval1.subsubodval1.firstval1', 'subodval1.subsubodval1.secondval1', 'subodval1.subsubodval1.thirdval1', 'subodval2.subsubodval2.firstval2', 'subodval2.subsubodval2.secondval2', 'subodval2.subsubodval2.thirdval2']:
return
# check if is a multi or a follower
multi = cfg.unrestraint.option(pathread).option.ismulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
@ -849,6 +917,9 @@ def autocheck_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kw
@autocheck
def autocheck_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
#FIXME
if pathwrite in ['odleader.first', 'subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2', 'subodval1.subsubodval1.firstval1', 'subodval1.subsubodval1.secondval1', 'subodval1.subsubodval1.thirdval1', 'subodval2.subsubodval2.firstval2', 'subodval2.subsubodval2.secondval2', 'subodval2.subsubodval2.thirdval2']:
return
_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs)
@ -856,6 +927,9 @@ def autocheck_property_permissive(cfg, mcfg, pathread, pathwrite, confread, conf
def autocheck_reset_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""check properties after set with permissive
"""
#FIXME
if pathwrite in ['odleader.first', 'subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2', 'subodval1.subsubodval1.firstval1', 'subodval1.subsubodval1.secondval1', 'subodval1.subsubodval1.thirdval1', 'subodval2.subsubodval2.firstval2', 'subodval2.subsubodval2.secondval2', 'subodval2.subsubodval2.thirdval2']:
return
# check if is a multi or a follower
multi = cfg.unrestraint.option(pathread).option.ismulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
@ -879,6 +953,9 @@ def autocheck_reset_property(cfg, mcfg, pathread, pathwrite, confread, confwrite
@autocheck
def autocheck_reset_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi or a follower
#FIXME
if pathwrite in ['odleader.first', 'subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2', 'subodval1.subsubodval1.firstval1', 'subodval1.subsubodval1.secondval1', 'subodval1.subsubodval1.thirdval1', 'subodval2.subsubodval2.firstval2', 'subodval2.subsubodval2.secondval2', 'subodval2.subsubodval2.thirdval2']:
return
multi = cfg.unrestraint.option(pathread).option.ismulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
default_props, properties = _getproperties(multi, isfollower, kwargs)
@ -902,6 +979,8 @@ def autocheck_context_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite,
def autocheck_owner_with_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""value is now changed, check owner in this case
"""
if pathwrite in ['odleader.first', 'subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2']:
return
_set_value(cfg, pathwrite, confwrite, **kwargs)
_check_owner(cfg, pathread, confwrite, kwargs, kwargs['owner'], kwargs['owner'])
if confread != confwrite:
@ -926,8 +1005,8 @@ def autocheck_default_owner_with_value(cfg, mcfg, pathread, pathwrite, confread,
if confwrite != confread:
assert cfg2_.option(pathread).owner.isdefault() is False
#FIXME else:
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathread).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confread).option(pathread).owner.isdefault()")
# with raises(PropertiesOptionError):cfg.config(confwrite).option(pathread).owner.isdefault()")
# with raises(PropertiesOptionError):cfg.config(confread).option(pathread).owner.isdefault()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg2_.option(pathread, 0).owner.isdefault() is True
@ -936,8 +1015,8 @@ def autocheck_default_owner_with_value(cfg, mcfg, pathread, pathwrite, confread,
assert cfg_.option(pathread, 0).owner.isdefault() is True
assert cfg_.option(pathread, 1).owner.isdefault() is False
#FIXME else:
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathread, 0).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confread).option(pathread, 0).owner.isdefault()")
# with raises(PropertiesOptionError):cfg.config(confwrite).option(pathread, 0).owner.isdefault()")
# with raises(PropertiesOptionError):cfg.config(confread).option(pathread, 0).owner.isdefault()")
@autocheck
@ -973,14 +1052,18 @@ def autocheck_set_owner_no_value(cfg, mcfg, pathread, pathwrite, confread, confw
cfg_ = cfg.forcepermissive
if not kwargs.get('propertyerror', False):
if not isfollower:
raises(ConfigError, "cfg_.option(pathwrite).owner.set('new_user')")
with raises(ConfigError):
cfg_.option(pathwrite).owner.set('new_user')
else:
raises(ConfigError, "cfg_.option(pathwrite, 1).owner.set('new_user')")
with raises(ConfigError):
cfg_.option(pathwrite, 1).owner.set('new_user')
@autocheck
def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# test set owner without permissive
if pathwrite in ['subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2']:
return
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
_set_value(cfg, pathwrite, confwrite, **kwargs)
@ -993,15 +1076,17 @@ def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
if not isfollower:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg_.option(pathwrite).owner.set('new_user')
raises(ValueError, "cfg_.option(pathwrite).owner.set('default')")
raises(ValueError, "cfg_.option(pathwrite).owner.set('forced')")
with raises(ValueError):
cfg_.option(pathwrite).owner.set('default')
with raises(ValueError):
cfg_.option(pathwrite).owner.set('forced')
#FIXME else:
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathwrite).owner.set('new_user')")
# with raises(PropertiesOptionError):cfg.config(confwrite).option(pathwrite).owner.set('new_user')")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg.option(pathwrite, 1).owner.set('new_user')
#FIXME else:
# raises(PropertiesOptionError, "cfg.option(pathwrite, 1).owner.set('new_user')")
# with raises(PropertiesOptionError):cfg.option(pathwrite, 1).owner.set('new_user')")
_check_owner(cfg, pathread, confwrite, kwargs, owners.new_user, kwargs['owner'])
if confwrite != confread:
@ -1010,6 +1095,8 @@ def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
@autocheck
def autocheck_set_owner_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
if pathwrite in ['subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2']:
return
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
_set_value(cfg, pathwrite, confwrite, **kwargs)
@ -1026,10 +1113,10 @@ def autocheck_set_owner_permissive(cfg, mcfg, pathread, pathwrite, confread, con
cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user1')
#FIXME else:
# if not isfollower:
# raises(PropertiesOptionError,
# with raises(PropertiesOptionError,
# "cfg.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user1')")
# else:
# raises(PropertiesOptionError,
# with raises(PropertiesOptionError,
# "cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user1')")
_check_owner(cfg, pathread, confwrite, kwargs, 'new_user1', 'new_user1')
@ -1039,6 +1126,9 @@ def autocheck_set_owner_permissive(cfg, mcfg, pathread, pathwrite, confread, con
@autocheck
def autocheck_option(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
#FIXME
if pathwrite.endswith('val1') or pathwrite.endswith('val2') or pathwrite in ['subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third']:
return
expected_name = pathread.split('.')[-1]
if not kwargs.get('permissive_od', False):
current_name = cfg.option(pathread).option.name()
@ -1048,18 +1138,24 @@ def autocheck_option(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwar
assert doc == cfg.forcepermissive.option(pathread).option.doc()
assert doc == cfg.unrestraint.option(pathread).option.doc()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.option(pathread).option.name()")
with raises(PropertiesOptionError):
cfg.option(pathread).option.name()
current_name = cfg.forcepermissive.option(pathread).option.name()
assert current_name == cfg.unrestraint.option(pathread).option.name()
raises(PropertiesOptionError, "cfg.option(pathread).option.doc()")
with raises(PropertiesOptionError):
cfg.option(pathread).option.doc()
doc = cfg.forcepermissive.option(pathread).option.doc()
assert doc == cfg.unrestraint.option(pathread).option.doc()
else:
raises(PropertiesOptionError, "cfg.option(pathread).option.name()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.name()")
with raises(PropertiesOptionError):
cfg.option(pathread).option.name()
with raises(PropertiesOptionError):
cfg.forcepermissive.option(pathread).option.name()
current_name = cfg.unrestraint.option(pathread).option.name()
raises(PropertiesOptionError, "cfg.option(pathread).option.doc()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.doc()")
with raises(PropertiesOptionError):
cfg.option(pathread).option.doc()
with raises(PropertiesOptionError):
cfg.forcepermissive.option(pathread).option.doc()
doc = cfg.unrestraint.option(pathread).option.doc()
assert current_name == expected_name
if expected_name.endswith('val1') or expected_name.endswith('val2'):
@ -1190,11 +1286,14 @@ def autocheck_find(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs
assert option == _getoption(cfg_.option.find(name, first=True))
assert option == _getoption(cfg_.forcepermissive.option.find(name, first=True))
elif kwargs.get('permissive', False):
raises(AttributeError, "cfg_.option.find(name, first=True)")
with raises(AttributeError):
cfg_.option.find(name, first=True)
assert option == _getoption(cfg_.forcepermissive.option.find(name, first=True))
else:
raises(AttributeError, "cfg_.option.find(name, first=True)")
raises(AttributeError, "cfg_.forcepermissive.option.find(name, first=True)")
with raises(AttributeError):
cfg_.option.find(name, first=True)
with raises(AttributeError):
cfg_.forcepermissive.option.find(name, first=True)
assert option == _getoption(cfg_.unrestraint.option.find(name, first=True))
assert [option] == _getoptions(cfg_.unrestraint.option.find(name))
do(confread)
@ -1372,11 +1471,11 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
for func in autocheck_registers:
cfg_name = 'conftest' + str(idx)
idx += 1
ncfg = cfg.config.copy(session_id=cfg_name)
ncfg = cfg.config.copy(name=cfg_name)
if meta:
confwrite = None
confread = cfg_name
mcfg = MetaConfig([ncfg], session_id='metatest')
mcfg = MetaConfig([ncfg], name='metatest')
weakrefs.append(weakref.ref(cfg))
else:
mcfg = ncfg
@ -1545,11 +1644,11 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
call_kwargs['requires'] = option_requires
else:
kwargs['requires'] = option_requires
if multi and path is not 'extraoptrequire':
if multi and path != 'extraoptrequire':
kwargs['multi'] = multi
if callback:
call_kwargs['multi'] = multi
if ((not in_leader or leader) and default) and path is not 'extraoptrequire' and not path.endswith('extraoptconsistency'):
if ((not in_leader or leader) and default) and path != 'extraoptrequire' and not path.endswith('extraoptconsistency'):
if multi is False:
value = FIRST_VALUE
elif multi is True:
@ -1563,7 +1662,7 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
kwargs['default'] = value
elif callback:
return None, None, None
if default_multi and path is not 'extraoptrequire':
if default_multi and path != 'extraoptrequire':
if multi is not submulti:
value = SECOND_VALUE
else:
@ -1585,7 +1684,6 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
tiramisu_option = SymLinkOption
else:
sobj = None
print(args, kwargs)
obj = tiramisu_option(*args, **kwargs)
return obj, objcall, sobj
@ -1678,7 +1776,7 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
rootod = make_optiondescriptions('root', collect_options)
if rootod is None:
return None, None, None
cfg = Config(rootod, session_id='conftest')
cfg = Config(rootod, name='conftest')
weakrefs.append(weakref.ref(cfg))
del goptions
return cfg, weakrefs, dyn

49
tests/config.py
View file

@ -21,11 +21,11 @@ except:
import pytest
async def get_config(config, type, error=False):
def get_config(config, type, error=False):
if type == 'tiramisu':
return config
if error:
await config.property.add('demoting_error_warning')
config.property.add('demoting_error_warning')
return TestConfig(config)
@ -35,51 +35,10 @@ def value_list(values):
return tuple(values)
async def global_owner(config, config_type):
return await config.owner.get()
def global_owner(config, config_type):
return config.owner.get()
@pytest.fixture(params=PARAMS)
def config_type(request):
return request.param
LOOP = None
@pytest.fixture(scope='session')
def event_loop(request):
"""Create an instance of the default event loop for each test case."""
global LOOP
if LOOP is None:
LOOP = asyncio.get_event_loop_policy().new_event_loop()
return LOOP
async def _delete_sessions(meta):
if await meta.config.type() != 'config':
for conf in await meta.config.list():
await _delete_sessions(conf)
await meta.session.reset()
async def delete_sessions(confs):
if not isinstance(confs, list):
confs = [confs]
for conf in confs:
await _delete_sessions(conf)
if environ.get('TIRAMISU_STORAGE') == 'postgres':
async with confs[0]._config_bag.context.getconnection() as connection:
assert await connection.fetchrow('SELECT * FROM session') is None
assert await connection.fetchrow('SELECT * FROM value') is None
assert await connection.fetchrow('SELECT * FROM information') is None
assert await connection.fetchrow('SELECT * FROM property') is None
assert await connection.fetchrow('SELECT * FROM permissive') is None
elif environ.get('TIRAMISU_STORAGE') == 'sqlite3':
async with confs[0]._config_bag.context.getconnection() as connection:
assert await connection.select('SELECT * FROM session') is None
assert await connection.select('SELECT * FROM value') is None
assert await connection.select('SELECT * FROM information') is None
assert await connection.select('SELECT * FROM property') is None
assert await connection.select('SELECT * FROM permissive') is None
else:
from tiramisu import list_sessions
assert not await list_sessions()

6
tests/dict/data/choice1_leadership_value.py
View file

@ -16,10 +16,10 @@ def get_description():
return descr
async def get_values(api, allpath=False):
def get_values(api, allpath=False):
if allpath:
root = 'choice1_leadership_value.'
else:
root = ''
await api.option(root + 'options.choice1.choice1').value.set(['choice 2'])
await api.option(root + 'options.choice1.choice2', 0).value.set('choice 4')
api.option(root + 'options.choice1.choice1').value.set(['choice 2'])
api.option(root + 'options.choice1.choice2', 0).value.set('choice 4')

1
tests/dict/data/filename1.json
View file

@ -29,7 +29,6 @@
"form": {
"usbpath": {
"clearable": true,
"pattern": "^[a-zA-Z0-9\\-\\._~/+]+$",
"type": "input"
},
"null": [

4
tests/dict/data/number1_mod_value.py
View file

@ -10,9 +10,9 @@ def get_description():
return descr
async def get_values(api, allpath=False):
def get_values(api, allpath=False):
if allpath:
root = 'number1_mod_value.'
else:
root = ''
await api.option(root + 'options.integer').value.set(3)
api.option(root + 'options.integer').value.set(3)

6
tests/dict/data/unicode1_leadership_hidden.py
View file

@ -16,10 +16,10 @@ def get_description():
return descr
async def get_values(api, allpath=False):
def get_values(api, allpath=False):
if allpath:
root = 'unicode1_leadership_hidden.'
else:
root = ''
await api.option(root + 'options.unicode.unicode').value.set([u'val1', u'val2'])
await api.option(root + 'options.unicode.unicode2', 0).value.set(u'super')
api.option(root + 'options.unicode.unicode').value.set([u'val1', u'val2'])
api.option(root + 'options.unicode.unicode2', 0).value.set(u'super')

14
tests/dict/data/unicode1_leadership_requires_disabled_value.py
View file

@ -20,14 +20,14 @@ def get_description():
return descr
async def get_values(api, allpath=False):
def get_values(api, allpath=False):
if allpath:
root = 'unicode1_leadership_requires_disabled_value.'
else:
root = ''
await api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2'])
await api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
await api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
await api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
await api.option(root + 'options.unicode.unicode2', 1).value.set(u'test')
await api.option(root + 'options.unicode.unicode3', 1).value.set(u'super')
api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2'])
api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
api.option(root + 'options.unicode.unicode2', 1).value.set(u'test')
api.option(root + 'options.unicode.unicode3', 1).value.set(u'super')

8
tests/dict/data/unicode1_leadership_requires_follower_value.py
View file

@ -19,11 +19,11 @@ def get_description():
return descr
async def get_values(api, allpath=False):
def get_values(api, allpath=False):
if allpath:
root = 'unicode1_leadership_requires_follower_value.'
else:
root = ''
await api.option(root + 'options.unicode1.unicode1').value.set([u'test', u'pas test'])
await api.option(root + 'options.unicode1.unicode2', 0).value.set(u'super1')
await api.option(root + 'options.unicode1.unicode3', 0).value.set(u'super1')
api.option(root + 'options.unicode1.unicode1').value.set([u'test', u'pas test'])
api.option(root + 'options.unicode1.unicode2', 0).value.set(u'super1')
api.option(root + 'options.unicode1.unicode3', 0).value.set(u'super1')

14
tests/dict/data/unicode1_leadership_requires_value.py
View file

@ -20,14 +20,14 @@ def get_description():
return descr
async def get_values(api, allpath=False):
def get_values(api, allpath=False):
if allpath:
root = 'unicode1_leadership_requires_value.'
else:
root = ''
await api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2'])
await api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
await api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
await api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
await api.option(root + 'options.unicode.unicode2', 1).value.set(u'test')
await api.option(root + 'options.unicode.unicode3', 1).value.set(u'super')
api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2'])
api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
api.option(root + 'options.unicode.unicode2', 1).value.set(u'test')
api.option(root + 'options.unicode.unicode3', 1).value.set(u'super')

14
tests/dict/data/unicode1_leadership_value.py
View file

@ -16,14 +16,14 @@ def get_description():
return descr
async def get_values(api, allpath=False):
def get_values(api, allpath=False):
if allpath:
root = 'unicode1_leadership_value.'
else:
root = ''
await api.option(root + 'options.unicode.unicode').value.set([u'val3', u'val4'])
await api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
await api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
await api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
await api.option(root + 'options.unicode.unicode2', 1).value.set(u'test')
await api.option(root + 'options.unicode.unicode3', 1).value.set(u'super')
api.option(root + 'options.unicode.unicode').value.set([u'val3', u'val4'])
api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
api.option(root + 'options.unicode.unicode2', 1).value.set(u'test')
api.option(root + 'options.unicode.unicode3', 1).value.set(u'super')

4
tests/dict/data/unicode1_mod_value.py
View file

@ -11,9 +11,9 @@ def get_description():
return descr
async def get_values(api, allpath=False):
def get_values(api, allpath=False):
if allpath:
root = 'unicode1_mod_value.'
else:
root = ''
await api.option(root + 'options.unicode').value.set('a')
api.option(root + 'options.unicode').value.set('a')

4
tests/dict/data/unicode1_multi_mod_value.py
View file

@ -11,9 +11,9 @@ def get_description():
return descr
async def get_values(api, allpath=False):
def get_values(api, allpath=False):
if allpath:
root = 'unicode1_multi_mod_value.'
else:
root = ''
await api.option(root + 'options.unicode').value.set(['c', 'd', 'e'])
api.option(root + 'options.unicode').value.set(['c', 'd', 'e'])

51
tests/dict/test_json.py
View file

@ -36,7 +36,7 @@ def list_data(ext='.py'):
return ret
async def load_config(filename,
def load_config(filename,
add_extra_od=False,
remote='minimum',
clearable='minimum',
@ -46,20 +46,20 @@ async def load_config(filename,
descr = mod.get_description()
if add_extra_od:
descr = OptionDescription('root', '', [descr])
config = await Config(descr)
await config.property.add('demoting_error_warning')
config = Config(descr)
config.property.add('demoting_error_warning')
if 'get_values' in dir(mod):
await mod.get_values(config, add_extra_od)
mod.get_values(config, add_extra_od)
form = [{'title': 'Configurer',
'type': 'submit'}]
if 'get_form' in dir(mod):
form.extend(mod.get_form(add_extra_od))
await config.property.read_write()
config.property.read_write()
if root is None:
values = loads(dumps(await config.option.dict(remotable=remote, clearable=clearable, form=form)))
values = loads(dumps(config.option.dict(remotable=remote, clearable=clearable, form=form)))
else:
values = loads(dumps(await config.option(root).dict(remotable=remote, clearable=clearable, form=form)))
values = loads(dumps(config.option(root).dict(remotable=remote, clearable=clearable, form=form)))
return values
@ -150,8 +150,7 @@ def filename_mod(request):
return request.param
@pytest.mark.asyncio
async def test_jsons(filename):
def test_jsons(filename):
debug = False
# debug = True
datadir = datapath()
@ -168,7 +167,7 @@ async def test_jsons(filename):
modulepath = splitext(filename)[0]
if debug:
print(" {} (remote: {}, clearable: {})".format(filename, remote, clearable))
values = await load_config(filename,
values = load_config(filename,
remote=remote,
clearable=clearable)
#
@ -217,8 +216,7 @@ async def test_jsons(filename):
assert values == expected, "error in file {}".format(filename)
@pytest.mark.asyncio
async def test_jsons_subconfig(filename):
def test_jsons_subconfig(filename):
debug = False
# debug = True
datadir = datapath()
@ -227,7 +225,7 @@ async def test_jsons_subconfig(filename):
modulepath = splitext(filename)[0]
if debug:
print(" ", filename)
values = await load_config(filename, add_extra_od=True, root=modulepath)
values = load_config(filename, add_extra_od=True, root=modulepath)
#
with open(join(datadir, modulepath + '.json'), 'r') as fh:
expected = loads(fh.read())
@ -292,8 +290,7 @@ async def test_jsons_subconfig(filename):
assert values == expected, "error in file {}".format(filename)
@pytest.mark.asyncio
async def test_updates(filename_mod):
def test_updates(filename_mod):
debug = False
# debug = True
datadir = datapath()
@ -362,31 +359,31 @@ async def test_updates(filename_mod):
if debug:
print(" (remote: {}, clearable: {}, issub {}, root {}, root_path {})".format(remote, clearable, issub, root, root_path))
for with_model in [False, True]:
config = await Config(descr)
await config.property.add('demoting_error_warning')
config = Config(descr)
config.property.add('demoting_error_warning')
if 'get_values' in dir(mod):
await mod.get_values(config, issub)
mod.get_values(config, issub)
if isfile(join(datadir, modulepath + '.mod')):
with open(join(datadir, modulepath + '.mod'), 'r') as fh:
await eval(fh.read())
eval(fh.read())
if dico_ori is None:
if clearable == 'minimum' and remote == 'minimum':
with open(join(datadir, modulepath + '.dict'), 'w') as fh:
dump(await config.value.dict(), fh, indent=2)
dump(config.value.dict(), fh, indent=2)
else:
assert await config.value.dict() == dico_ori, "clearable {}, remote: {}, filename: {}".format(clearable, remote, filename_mod)
assert config.value.dict() == dico_ori, "clearable {}, remote: {}, filename: {}".format(clearable, remote, filename_mod)
if root is None:
suboption = config.option
else:
suboption = config.option(root)
if with_model:
bodym = body.copy()
bodym['model'] = loads(dumps(await suboption.dict(remotable=remote, clearable=clearable)))['model']
bodym['model'] = loads(dumps(suboption.dict(remotable=remote, clearable=clearable)))['model']
else:
await suboption.dict(remotable=remote, clearable=clearable)
suboption.dict(remotable=remote, clearable=clearable)
bodym = body
if with_model:
cal_values = await suboption.updates(bodym)
cal_values = suboption.updates(bodym)
if values is None:
if clearable == 'minimum' and remote == 'minimum':
with open(join(datadir, modulepath + '.updates{}'.format(idx)), 'w') as fh:
@ -399,10 +396,10 @@ async def test_updates(filename_mod):
pprint(values)
assert cal_values == values
else:
assert await suboption.updates(bodym) == {}
assert suboption.updates(bodym) == {}
if dico_mod is None:
if clearable == 'minimum' and remote == 'minimum':
with open(join(datadir, modulepath + '.dict{}'.format(idx)), 'w') as fh:
dump(await config.value.dict(), fh, indent=2)
dump(config.value.dict(), fh, indent=2)
else:
assert await config.value.dict() == dico_mod
assert config.value.dict() == dico_mod

389
tests/test_cache.py
View file

@ -1,16 +1,13 @@
# coding: utf-8
from time import sleep, time
import pytest
from .autopath import do_autopath
do_autopath()
from tiramisu import BoolOption, IPOption, IntOption, StrOption, OptionDescription, Leadership, Config, \
undefined, Calculation, Params, ParamValue, ParamOption, \
list_sessions, default_storage, delete_session, calc_value
undefined, Calculation, Params, ParamValue, ParamOption, calc_value
from tiramisu.error import ConfigError, PropertiesOptionError
from tiramisu.setting import groups
from .config import event_loop
global incr
@ -28,247 +25,238 @@ def make_description():
return OptionDescription('od1', '', [u1, u2, u3])
@pytest.mark.asyncio
async def test_cache_config():
def test_cache_config():
od1 = make_description()
assert od1.impl_already_build_caches() is False
async with await Config(od1) as cfg:
cfg = Config(od1)
assert od1.impl_already_build_caches() is True
cfg
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache():
def test_cache():
od1 = make_description()
async with await Config(od1) as cfg:
cfg = Config(od1)
values = cfg._config_bag.context._impl_values_cache
settings = cfg._config_bag.context._impl_properties_cache
await cfg.option('u1').value.get()
settings = cfg._config_bag.context.properties_cache
cfg.option('u1').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
await cfg.option('u2').value.get()
cfg.option('u2').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u2' in values.get_cached()
assert 'u2' in settings.get_cached()
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_importation():
def test_cache_importation():
od1 = make_description()
async with await Config(od1) as cfg:
await cfg.option('u2').value.set(1)
export = await cfg.value.exportation()
assert await cfg.value.dict() == {'u1': [], 'u2': 1, 'u3': []}
await cfg.option('u2').value.set(2)
assert await cfg.value.dict() == {'u1': [], 'u2': 2, 'u3': []}
await cfg.value.importation(export)
assert await cfg.value.dict() == {'u1': [], 'u2': 1, 'u3': []}
assert not await list_sessions()
cfg = Config(od1)
cfg.option('u2').value.set(1)
export = cfg.value.exportation()
assert cfg.value.dict() == {'u1': [], 'u2': 1, 'u3': []}
cfg.option('u2').value.set(2)
assert cfg.value.dict() == {'u1': [], 'u2': 2, 'u3': []}
cfg.value.importation(export)
assert cfg.value.dict() == {'u1': [], 'u2': 1, 'u3': []}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_importation_property():
def test_cache_importation_property():
od1 = make_description()
async with await Config(od1) as cfg:
await cfg.option('u2').property.add('prop')
export = await cfg.property.exportation()
assert await cfg.option('u2').property.get() == {'prop'}
await cfg.option('u2').property.add('prop2')
assert await cfg.option('u2').property.get() == {'prop', 'prop2'}
await cfg.property.importation(export)
assert await cfg.option('u2').property.get() == {'prop'}
assert not await list_sessions()
cfg = Config(od1)
cfg.option('u2').property.add('prop')
export = cfg.property.exportation()
assert cfg.option('u2').property.get() == {'prop'}
cfg.option('u2').property.add('prop2')
assert cfg.option('u2').property.get() == {'prop', 'prop2'}
cfg.property.importation(export)
assert cfg.option('u2').property.get() == {'prop'}
cfg = Config(od1)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_importation_permissive():
def test_cache_importation_permissive():
od1 = make_description()
async with await Config(od1) as cfg:
await cfg.option('u2').permissive.set(frozenset(['prop']))
export = await cfg.permissive.exportation()
assert await cfg.option('u2').permissive.get() == {'prop'}
await cfg.option('u2').permissive.set(frozenset(['prop', 'prop2']))
assert await cfg.option('u2').permissive.get() == {'prop', 'prop2'}
await cfg.permissive.importation(export)
assert await cfg.option('u2').permissive.get() == {'prop'}
assert not await list_sessions()
cfg = Config(od1)
cfg.option('u2').permissive.set(frozenset(['prop']))
export = cfg.permissive.exportation()
assert cfg.option('u2').permissive.get() == {'prop'}
cfg.option('u2').permissive.set(frozenset(['prop', 'prop2']))
assert cfg.option('u2').permissive.get() == {'prop', 'prop2'}
cfg.permissive.importation(export)
assert cfg.option('u2').permissive.get() == {'prop'}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_reset():
def test_cache_reset():
od1 = make_description()
async with await Config(od1) as cfg:
cfg = Config(od1)
values = cfg._config_bag.context._impl_values_cache
settings = cfg._config_bag.context._impl_properties_cache
settings = cfg._config_bag.context.properties_cache
#when change a value
await cfg.option('u1').value.get()
await cfg.option('u2').value.get()
cfg.option('u1').value.get()
cfg.option('u2').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u2' in values.get_cached()
assert 'u2' in settings.get_cached()
assert 'u1' in values.get_cached()
settings.get_cached()
await cfg.option('u2').value.set(1)
cfg.option('u2').value.set(1)
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u2' in values.get_cached()
assert 'u2' not in settings.get_cached()
#when remove a value
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
await cfg.option('u2').value.reset()
cfg.option('u2').value.reset()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u2' not in values.get_cached()
assert 'u2' not in settings.get_cached()
#when add/del property
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
await cfg.option('u2').property.add('test')
cfg.option('u2').property.add('test')
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u2' not in values.get_cached()
assert 'u2' not in settings.get_cached()
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
await cfg.option('u2').property.pop('test')
cfg.option('u2').property.remove('test')
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u2' not in values.get_cached()
assert 'u2' not in settings.get_cached()
#when enable/disabled property
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
await cfg.property.add('test')
cfg.property.add('test')
assert 'u1' not in values.get_cached()
assert 'u1' not in settings.get_cached()
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
await cfg.property.pop('test')
cfg.property.remove('test')
assert 'u1' not in values.get_cached()
assert 'u1' not in settings.get_cached()
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_reset_multi():
def test_cache_reset_multi():
od1 = make_description()
async with await Config(od1) as cfg:
cfg = Config(od1)
values = cfg._config_bag.context._impl_values_cache
settings = cfg._config_bag.context._impl_properties_cache
await cfg.option('u1').value.get()
await cfg.option('u3').value.get()
settings = cfg._config_bag.context.properties_cache
cfg.option('u1').value.get()
cfg.option('u3').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u3' in values.get_cached()
assert 'u3' in settings.get_cached()
#when change a value
await cfg.option('u3').value.set([1])
cfg.option('u3').value.set([1])
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u3' in values.get_cached()
assert 'u3' not in settings.get_cached()
#when append value
await cfg.option('u1').value.get()
await cfg.option('u3').value.get()
cfg.option('u1').value.get()
cfg.option('u3').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u3' in values.get_cached()
assert 'u3' in settings.get_cached()
await cfg.option('u3').value.set([1, 2])
cfg.option('u3').value.set([1, 2])
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u3' in values.get_cached()
assert 'u3' not in settings.get_cached()
#when pop value
await cfg.option('u1').value.get()
await cfg.option('u3').value.get()
cfg.option('u1').value.get()
cfg.option('u3').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u3' in values.get_cached()
assert 'u3' in settings.get_cached()
await cfg.option('u3').value.set([1])
cfg.option('u3').value.set([1])
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u3' in values.get_cached()
assert 'u3' not in settings.get_cached()
#when remove a value
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
await cfg.option('u3').value.reset()
cfg.option('u3').value.reset()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u3' not in values.get_cached()
assert 'u3' not in settings.get_cached()
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_reset_cache():
def test_reset_cache():
od1 = make_description()
async with await Config(od1) as cfg:
cfg = Config(od1)
values = cfg._config_bag.context._impl_values_cache
settings = cfg._config_bag.context._impl_properties_cache
await cfg.option('u1').value.get()
settings = cfg._config_bag.context.properties_cache
cfg.option('u1').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
await cfg.cache.reset()
cfg.cache.reset()
assert 'u1' not in values.get_cached()
assert 'u1' not in settings.get_cached()
await cfg.option('u1').value.get()
await cfg.option('u2').value.get()
cfg.option('u1').value.get()
cfg.option('u2').value.get()
assert 'u1' in values.get_cached()
assert 'u1' in settings.get_cached()
assert 'u2' in values.get_cached()
assert 'u2' in settings.get_cached()
await cfg.cache.reset()
cfg.cache.reset()
assert 'u1' not in values.get_cached()
assert 'u1' not in settings.get_cached()
assert 'u2' not in values.get_cached()
assert 'u2' not in settings.get_cached()
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_not_cache():
def test_cache_not_cache():
od1 = make_description()
async with await Config(od1) as cfg:
cfg = Config(od1)
values = cfg._config_bag.context._impl_values_cache
settings = cfg._config_bag.context._impl_properties_cache
await cfg.property.pop('cache')
await cfg.option('u1').value.get()
settings = cfg._config_bag.context.properties_cache
cfg.property.remove('cache')
cfg.option('u1').value.get()
assert 'u1' not in values.get_cached()
assert 'u1' not in settings.get_cached()
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_leadership():
def test_cache_leadership():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
od1 = OptionDescription('toto', '', [interface1])
async with await Config(od1) as cfg:
await cfg.property.read_write()
cfg = Config(od1)
cfg.property.read_write()
values = cfg._config_bag.context._impl_values_cache
settings = cfg._config_bag.context._impl_properties_cache
settings = cfg._config_bag.context.properties_cache
assert values.get_cached() == {}
#assert settings.get_cached() == {}
#
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
cache = values.get_cached()
assert set(cache.keys()) == set(['ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
assert set(cache['ip_admin_eth0.ip_admin_eth0'].keys()) == set([None])
@ -282,10 +270,10 @@ async def test_cache_leadership():
assert set(cache['ip_admin_eth0.ip_admin_eth0'].keys()) == set([None])
assert set(cache['ip_admin_eth0.netmask_admin_eth0'].keys()) == set([0, None])
#
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()
cache = values.get_cached()
assert set(cache.keys()) == set(['ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
assert set(cache['ip_admin_eth0.ip_admin_eth0'].keys()) == set([None])
@ -300,7 +288,7 @@ async def test_cache_leadership():
assert set(cache['ip_admin_eth0.ip_admin_eth0'].keys()) == set([None])
assert set(cache['ip_admin_eth0.netmask_admin_eth0'].keys()) == set([None, 0, 1])
#DEL, insert, ...
assert not await list_sessions()
# assert not list_sessions()
def compare(calculated, expected):
@ -312,83 +300,81 @@ def compare(calculated, expected):
assert calculated[calculated_key][calculated_subkey][0] == expected[calculated_key][calculated_subkey][0]
@pytest.mark.asyncio
async def test_cache_callback():
def test_cache_callback():
val1 = StrOption('val1', "", 'val')
val2 = StrOption('val2', "", Calculation(calc_value, Params(ParamOption(val1))), properties=('mandatory',))
val3 = StrOption('val3', "", Calculation(calc_value, Params(ParamValue('yes'))))
val4 = StrOption('val4', "", Calculation(calc_value, Params(ParamOption(val1))))
val5 = StrOption('val5', "", [Calculation(calc_value, Params(ParamValue('yes')))], multi=True)
od1 = OptionDescription('rootconfig', '', [val1, val2, val3, val4, val5])
async with await Config(od1) as cfg:
await cfg.property.read_write()
await cfg.value.dict()
cfg = Config(od1)
cfg.property.read_write()
cfg.value.dict()
values = cfg._config_bag.context._impl_values_cache
settings = cfg._config_bag.context._impl_properties_cache
settings = cfg._config_bag.context.properties_cache
compare(values.get_cached(), {'val1': {None: ('val', None)},
'val2': {None: ('val', None)},
'val3': {None: ('yes', None)},
'val4': {None: ('val', None)},
'val5': {None: (['yes'], None)}})
await cfg.option('val1').value.set('new')
cfg.option('val1').value.set('new')
compare(values.get_cached(), {'val3': {None: ('yes', None)},
'val1': {None: ('new', None)},
'val5': {None: (['yes'], None)}})
await cfg.value.dict()
cfg.value.dict()
compare(values.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('yes', None)},
'val4': {None: ('new', None)},
'val5': {None: (['yes'], None)}})
await cfg.option('val3').value.set('new2')
cfg.option('val3').value.set('new2')
compare(values.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val4': {None: ('new', None)},
'val1': {None: ('new', None)},
'val3': {None: ('new2', None, True)},
'val5': {None: (['yes'], None)}})
await cfg.value.dict()
cfg.value.dict()
compare(values.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('new2', None)},
'val4': {None: ('new', None)},
'val5': {None: (['yes'], None)}})
await cfg.option('val4').value.set('new3')
cfg.option('val4').value.set('new3')
compare(values.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('new2', None)},
'val4': {None: ('new3', None, True)},
'val5': {None: (['yes'], None)}})
await cfg.value.dict()
cfg.value.dict()
compare(values.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('new2', None)},
'val4': {None: ('new3', None)},
'val5': {None: (['yes'], None)}})
await cfg.option('val5').value.set([undefined, 'new4'])
cfg.option('val5').value.set([undefined, 'new4'])
compare(values.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('new2', None)},
'val4': {None: ('new3', None)},
'val5': {None: (['yes', 'new4'], None)}})
await cfg.value.dict()
cfg.value.dict()
compare(values.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('new2', None)},
'val4': {None: ('new3', None)},
'val5': {None: (['yes', 'new4'], None)}})
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_leader_and_followers():
def test_cache_leader_and_followers():
val1 = StrOption('val1', "", multi=True)
val2 = StrOption('val2', "", multi=True)
interface1 = Leadership('val1', '', [val1, val2])
od1 = OptionDescription('rootconfig', '', [interface1])
async with await Config(od1) as cfg:
await cfg.property.read_write()
await cfg.value.dict()
cfg = Config(od1)
cfg.property.read_write()
cfg.value.dict()
global_props = ['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']
val1_props = []
val1_val1_props = ['empty', 'unique']
@ -400,7 +386,7 @@ async 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._impl_properties_cache
settings = cfg._config_bag.context.properties_cache
compare(settings.get_cached(), {None: {None: (global_props, None)},
'val1': {None: (val1_props, None)},
'val1.val1': {None: (val1_val1_props, None)},
@ -408,13 +394,13 @@ async def test_cache_leader_and_followers():
# len is 0 so don't get any value
compare(values.get_cached(), {'val1.val1': {None: ([], None)}})
#
await cfg.option('val1.val1').value.set([undefined])
cfg.option('val1.val1').value.set([undefined])
val_val2_props = {idx_val2: (val1_val2_props, None), None: (set(), None)}
compare(settings.get_cached(), {None: {None: (set(global_props), None)},
'val1.val1': {None: (val1_val1_props, None)},
'val1.val2': val_val2_props})
compare(values.get_cached(), {'val1.val1': {None: ([None], None, True)}})
await cfg.value.dict()
cfg.value.dict()
#has value
idx_val2 = 0
val_val2 = None
@ -425,24 +411,23 @@ async def test_cache_leader_and_followers():
'val1.val2': val_val2_props})
compare(values.get_cached(), {'val1.val1': {None: ([None], None)},
'val1.val2': {idx_val2: (val_val2, None)}})
await cfg.option('val1.val1').value.set([undefined, undefined])
await cfg.value.dict()
await cfg.option('val1.val2', 1).value.set('oui')
cfg.option('val1.val1').value.set([undefined, undefined])
cfg.value.dict()
cfg.option('val1.val2', 1).value.set('oui')
compare(settings.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']), None)}})
compare(values.get_cached(), {'val1.val2': {1: ('oui', None, True)}})
val1_val2_props = {0: (frozenset([]), None), 1: (frozenset([]), None)}
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_leader_callback():
def test_cache_leader_callback():
val1 = StrOption('val1', "", multi=True)
val2 = StrOption('val2', "", Calculation(calc_value, Params(kwargs={'value': ParamOption(val1)})), multi=True)
interface1 = Leadership('val1', '', [val1, val2])
od1 = OptionDescription('rootconfig', '', [interface1])
async with await Config(od1) as cfg:
await cfg.property.read_write()
await cfg.value.dict()
cfg = Config(od1)
cfg.property.read_write()
cfg.value.dict()
global_props = ['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']
val1_props = []
val1_val1_props = ['empty', 'unique']
@ -452,24 +437,23 @@ async 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._impl_properties_cache
settings = cfg._config_bag.context.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)}})
await cfg.option('val1.val1').value.set([undefined])
cfg.option('val1.val1').value.set([undefined])
compare(settings.get_cached(), {None: {None: (set(global_props), None)},
'val1.val1': {None: (val1_val1_props, None)},
'val1.val2': {None: (val1_val2_props, None)}})
compare(values.get_cached(), {'val1.val1': {None: ([None], None, True)}})
await cfg.value.dict()
assert not await list_sessions()
cfg.value.dict()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_requires():
def test_cache_requires():
a = BoolOption('activate_service', '', True)
disabled_property = Calculation(calc_value,
Params(ParamValue('disabled'),
@ -478,52 +462,51 @@ async def test_cache_requires():
'default': ParamValue(None)}))
b = IPOption('ip_address_service', '', properties=(disabled_property,))
od1 = OptionDescription('service', '', [a, b])
async with await Config(od1) as cfg:
await cfg.property.read_write()
cfg = Config(od1)
cfg.property.read_write()
values = cfg._config_bag.context._impl_values_cache
settings = cfg._config_bag.context._impl_properties_cache
settings = cfg._config_bag.context.properties_cache
assert values.get_cached() == {}
assert await cfg.option('ip_address_service').value.get() == None
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)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
compare(values.get_cached(), {'ip_address_service': {None: (None, None)},
'activate_service': {None: (True, None)}})
await cfg.value.dict()
cfg.value.dict()
compare(settings.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
compare(values.get_cached(), {'ip_address_service': {None: (None, None)},
'activate_service': {None: (True, None)}})
await cfg.option('ip_address_service').value.set('1.1.1.1')
cfg.option('ip_address_service').value.set('1.1.1.1')
compare(settings.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']), None)},
'activate_service': {None: (set([]), None)}})
compare(values.get_cached(), {'activate_service': {None: (True, None)}, 'ip_address_service': {None: ('1.1.1.1', None, True)}})
await cfg.value.dict()
cfg.value.dict()
compare(settings.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
compare(values.get_cached(), {'ip_address_service': {None: ('1.1.1.1', None)},
'activate_service': {None: (True, None)}})
await cfg.option('activate_service').value.set(False)
cfg.option('activate_service').value.set(False)
compare(settings.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']), None)}})
compare(values.get_cached(), {'activate_service': {None: (False, None)}})
await cfg.value.dict()
cfg.value.dict()
compare(settings.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set(['disabled']), None)}})
compare(values.get_cached(), {'activate_service': {None: (False, None)}})
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_cache_global_properties():
def test_cache_global_properties():
a = BoolOption('activate_service', '', True)
disabled_property = Calculation(calc_value,
Params(ParamValue('disabled'),
@ -532,79 +515,77 @@ async def test_cache_global_properties():
'default': ParamValue(None)}))
b = IPOption('ip_address_service', '', properties=(disabled_property,))
od1 = OptionDescription('service', '', [a, b])
async with await Config(od1) as cfg:
await cfg.property.read_write()
cfg = Config(od1)
cfg.property.read_write()
values = cfg._config_bag.context._impl_values_cache
settings = cfg._config_bag.context._impl_properties_cache
settings = cfg._config_bag.context.properties_cache
assert values.get_cached() == {}
assert await cfg.option('ip_address_service').value.get() == None
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)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
compare(values.get_cached(), {'ip_address_service': {None: (None, None)},
'activate_service': {None: (True, None)}})
await cfg.property.pop('disabled')
assert await cfg.option('ip_address_service').value.get() == None
cfg.property.remove('disabled')
assert cfg.option('ip_address_service').value.get() == None
compare(settings.get_cached(), {None: {None: (set(['cache', 'frozen', 'hidden', 'validator', 'warnings', 'force_store_value']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
await cfg.property.add('test')
assert await cfg.option('ip_address_service').value.get() == None
cfg.property.add('test')
assert cfg.option('ip_address_service').value.get() == None
compare(settings.get_cached(), {None: {None: (set(['cache', 'frozen', 'hidden', 'validator', 'warnings', 'test', 'force_store_value']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_callback_value_incr():
def test_callback_value_incr():
global incr
incr = -1
val1 = IntOption('val1', "", Calculation(return_incr), properties=('expire',))
val2 = IntOption('val2', "", Calculation(calc_value, Params(ParamOption(val1))))
od1 = OptionDescription('rootconfig', '', [val1, val2])
async with await Config(od1) as cfg:
assert await cfg.cache.get_expiration_time() == 5
await cfg.cache.set_expiration_time(1)
assert await cfg.cache.get_expiration_time() == 1
await cfg.property.read_write()
assert await cfg.option('val1').value.get() == 1
cfg = Config(od1)
assert cfg.cache.get_expiration_time() == 5
cfg.cache.set_expiration_time(1)
assert cfg.cache.get_expiration_time() == 1
cfg.property.read_write()
assert cfg.option('val1').value.get() == 1
sleep(1)
assert await cfg.option('val2').value.get() == 1
assert cfg.option('val2').value.get() == 1
sleep(1)
assert await cfg.option('val1').value.get() == 1
assert await cfg.option('val2').value.get() == 1
assert cfg.option('val1').value.get() == 1
assert cfg.option('val2').value.get() == 1
sleep(2)
assert await cfg.option('val1').value.get() == 2
assert await cfg.option('val2').value.get() == 2
assert await cfg.option('val1').value.get() == 2
assert await cfg.option('val2').value.get() == 2
assert not await list_sessions()
assert cfg.option('val1').value.get() == 2
assert cfg.option('val2').value.get() == 2
assert cfg.option('val1').value.get() == 2
assert cfg.option('val2').value.get() == 2
# assert not list_sessions()
@pytest.mark.asyncio
async def test_callback_value_incr_demoting():
def test_callback_value_incr_demoting():
global incr
incr = -1
val1 = IntOption('val1', "", Calculation(return_incr), properties=('expire',))
val2 = IntOption('val2', "", Calculation(calc_value, Params(ParamOption(val1))))
od1 = OptionDescription('rootconfig', '', [val1, val2])
async with await Config(od1) as cfg:
await cfg.property.add('demoting_error_warning')
assert await cfg.cache.get_expiration_time() == 5
await cfg.cache.set_expiration_time(1)
assert await cfg.cache.get_expiration_time() == 1
await cfg.property.read_write()
assert await cfg.option('val1').value.get() == 1
cfg = Config(od1)
cfg.property.add('demoting_error_warning')
assert cfg.cache.get_expiration_time() == 5
cfg.cache.set_expiration_time(1)
assert cfg.cache.get_expiration_time() == 1
cfg.property.read_write()
assert cfg.option('val1').value.get() == 1
sleep(1)
assert await cfg.option('val2').value.get() == 1
assert cfg.option('val2').value.get() == 1
sleep(1)
assert await cfg.option('val1').value.get() == 1
assert await cfg.option('val2').value.get() == 1
assert cfg.option('val1').value.get() == 1
assert cfg.option('val2').value.get() == 1
sleep(2)
assert await cfg.option('val1').value.get() == 2
assert await cfg.option('val2').value.get() == 2
assert await cfg.option('val1').value.get() == 2
assert await cfg.option('val2').value.get() == 2
assert not await list_sessions()
assert cfg.option('val1').value.get() == 2
assert cfg.option('val2').value.get() == 2
assert cfg.option('val1').value.get() == 2
assert cfg.option('val2').value.get() == 2
# assert not list_sessions()

306
tests/test_choice_option.py
View file

@ -1,13 +1,12 @@
# coding: utf-8
from py.test import raises
import pytest
from .autopath import do_autopath
do_autopath()
from .config import config_type, get_config, value_list, global_owner, event_loop
from .config import config_type, get_config, value_list, global_owner
from tiramisu import ChoiceOption, StrOption, OptionDescription, Config, owners, Calculation, \
undefined, Params, ParamValue, ParamOption, list_sessions
undefined, Params, ParamValue, ParamOption
from tiramisu.error import ConfigError
@ -27,155 +26,146 @@ def return_error(*args, **kwargs):
raise Exception('test')
@pytest.mark.asyncio
async def test_choiceoption(config_type):
def test_choiceoption(config_type):
choice = ChoiceOption('choice', '', values=('val1', 'val2'))
odesc = OptionDescription('od', '', [choice])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
owner = await global_owner(cfg, config_type)
assert await cfg.option('choice').owner.get() == owners.default
assert await cfg.option('choice').owner.isdefault()
od1 = OptionDescription('od', '', [choice])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
owner = global_owner(cfg, config_type)
assert cfg.option('choice').owner.get() == owners.default
assert cfg.option('choice').owner.isdefault()
#
await cfg.option('choice').value.set('val1')
assert await cfg.option('choice').owner.get() == owner
assert not await cfg.option('choice').owner.isdefault()
cfg.option('choice').value.set('val1')
assert cfg.option('choice').owner.get() == owner
assert not cfg.option('choice').owner.isdefault()
#
await cfg.option('choice').value.reset()
assert await cfg.option('choice').owner.get() == owners.default
assert await cfg.option('choice').owner.isdefault()
cfg.option('choice').value.reset()
assert cfg.option('choice').owner.get() == owners.default
assert cfg.option('choice').owner.isdefault()
#
with pytest.raises(ValueError):
await cfg.option('choice').value.set('no')
assert await cfg.option('choice').owner.get() == owners.default
assert await cfg.option('choice').owner.isdefault()
with raises(ValueError):
cfg.option('choice').value.set('no')
assert cfg.option('choice').owner.get() == owners.default
assert cfg.option('choice').owner.isdefault()
#
assert value_list(await cfg.option('choice').value.list()) == ('val1', 'val2')
assert not await list_sessions()
assert value_list(cfg.option('choice').value.list()) == ('val1', 'val2')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choiceoption_function(config_type):
def test_choiceoption_function(config_type):
choice = ChoiceOption('choice', '', values=Calculation(return_list))
odesc = OptionDescription('od', '', [choice])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
owner = await global_owner(cfg, config_type)
assert await cfg.option('choice').owner.isdefault()
od1 = OptionDescription('od', '', [choice])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
owner = global_owner(cfg, config_type)
assert cfg.option('choice').owner.isdefault()
#
await cfg.option('choice').value.set('val1')
assert await cfg.option('choice').owner.get() == owner
cfg.option('choice').value.set('val1')
assert cfg.option('choice').owner.get() == owner
#
await cfg.option('choice').value.reset()
assert await cfg.option('choice').owner.isdefault()
cfg.option('choice').value.reset()
assert cfg.option('choice').owner.isdefault()
#
with pytest.raises(ValueError):
await cfg.option('choice').value.set('no')
assert await cfg.option('choice').owner.isdefault()
with raises(ValueError):
cfg.option('choice').value.set('no')
assert cfg.option('choice').owner.isdefault()
#
assert value_list(await cfg.option('choice').value.list()) == ('val1', 'val2')
assert not await list_sessions()
assert value_list(cfg.option('choice').value.list()) == ('val1', 'val2')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choiceoption_function_error():
def test_choiceoption_function_error():
choice = ChoiceOption('choice', '', values=Calculation(return_error))
odesc = OptionDescription('od', '', [choice])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
with pytest.raises(ConfigError):
await cfg.option('choice').value.set('val1')
assert not await list_sessions()
od1 = OptionDescription('od', '', [choice])
cfg = Config(od1)
cfg.property.read_write()
with raises(ConfigError):
cfg.option('choice').value.set('val1')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choiceoption_function_error_args():
def test_choiceoption_function_error_args():
choice = ChoiceOption('choice', '', values=Calculation(return_error, Params(ParamValue('val1'))))
odesc = OptionDescription('od', '', [choice])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
with pytest.raises(ConfigError):
await cfg.option('choice').value.set('val1')
assert not await list_sessions()
od1 = OptionDescription('od', '', [choice])
cfg = Config(od1)
cfg.property.read_write()
with raises(ConfigError):
cfg.option('choice').value.set('val1')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choiceoption_function_error_kwargs():
def test_choiceoption_function_error_kwargs():
choice = ChoiceOption('choice', '', values=Calculation(return_error, Params(kwargs={'kwargs': ParamValue('val1')})))
odesc = OptionDescription('od', '', [choice])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
with pytest.raises(ConfigError):
await cfg.option('choice').value.set('val1')
assert not await list_sessions()
od1 = OptionDescription('od', '', [choice])
cfg = Config(od1)
cfg.property.read_write()
with raises(ConfigError):
cfg.option('choice').value.set('val1')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choiceoption_calc_function(config_type):
def test_choiceoption_calc_function(config_type):
choice = ChoiceOption('choice', "", values=Calculation(return_calc_list, Params(ParamValue('val1'))))
odesc = OptionDescription('od', '', [choice])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
owner = await global_owner(cfg, config_type)
assert await cfg.option('choice').owner.isdefault()
od1 = OptionDescription('od', '', [choice])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
owner = global_owner(cfg, config_type)
assert cfg.option('choice').owner.isdefault()
#
await cfg.option('choice').value.set('val1')
assert await cfg.option('choice').owner.get() == owner
cfg.option('choice').value.set('val1')
assert cfg.option('choice').owner.get() == owner
#
await cfg.option('choice').value.reset()
assert await cfg.option('choice').owner.isdefault()
cfg.option('choice').value.reset()
assert cfg.option('choice').owner.isdefault()
#
with pytest.raises(ValueError):
await cfg.option('choice').value.set('no')
assert await cfg.option('choice').owner.isdefault()
assert not await list_sessions()
with raises(ValueError):
cfg.option('choice').value.set('no')
assert cfg.option('choice').owner.isdefault()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choiceoption_calc_opt_function(config_type):
def test_choiceoption_calc_opt_function(config_type):
str_ = StrOption('str', '', 'val1')
choice = ChoiceOption('choice',
"",
values=Calculation(return_calc_list, Params(ParamOption(str_))))
odesc = OptionDescription('od', '', [str_, choice])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
cfg = await get_config(cfg, config_type)
assert await cfg.option('choice').owner.isdefault()
od1 = OptionDescription('od', '', [str_, choice])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
cfg = get_config(cfg, config_type)
assert cfg.option('choice').owner.isdefault()
#
await cfg.option('choice').value.set('val1')
assert await cfg.option('choice').owner.get() == owner
cfg.option('choice').value.set('val1')
assert cfg.option('choice').owner.get() == owner
#
await cfg.option('choice').value.reset()
assert await cfg.option('choice').owner.isdefault()
cfg.option('choice').value.reset()
assert cfg.option('choice').owner.isdefault()
#
with pytest.raises(ValueError):
await cfg.option('choice').value.set('no')
assert await cfg.option('choice').owner.isdefault()
assert not await list_sessions()
with raises(ValueError):
cfg.option('choice').value.set('no')
assert cfg.option('choice').owner.isdefault()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choiceoption_calc_opt_function_propertyerror():
def test_choiceoption_calc_opt_function_propertyerror():
str_ = StrOption('str', '', 'val1', properties=('disabled',))
choice = ChoiceOption('choice',
"",
values=Calculation(return_calc_list, Params(ParamOption(str_))))
odesc = OptionDescription('od', '', [str_, choice])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
with pytest.raises(ConfigError):
await cfg.option('choice').value.set('no')
assert not await list_sessions()
od1 = OptionDescription('od', '', [str_, choice])
cfg = Config(od1)
cfg.property.read_write()
with raises(ConfigError):
cfg.option('choice').value.set('no')
# assert not list_sessions()
#def test_choiceoption_calc_opt_multi_function(config_type):
@pytest.mark.asyncio
async def test_choiceoption_calc_opt_multi_function():
def test_choiceoption_calc_opt_multi_function():
# FIXME
config_type = 'tiramisu'
str_ = StrOption('str', '', ['val1'], multi=True)
@ -189,37 +179,36 @@ async def test_choiceoption_calc_opt_multi_function():
default=['val2'],
values=Calculation(return_val, Params(ParamOption(str_))),
multi=True)
odesc = OptionDescription('od', '', [str_, choice, ch2])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
cfg = await get_config(cfg, config_type, True)
assert await cfg.option('choice').owner.isdefault()
assert await cfg.option('choice').value.get() == []
od1 = OptionDescription('od', '', [str_, choice, ch2])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
cfg = get_config(cfg, config_type, True)
assert cfg.option('choice').owner.isdefault()
assert cfg.option('choice').value.get() == []
#
await cfg.option('choice').value.set(['val1'])
assert await cfg.option('choice').owner.get() == owner
cfg.option('choice').value.set(['val1'])
assert cfg.option('choice').owner.get() == owner
#
with pytest.raises(ValueError):
await cfg.option('choice').value.set([undefined])
with raises(ValueError):
cfg.option('choice').value.set([undefined])
#
await cfg.option('choice').value.set(['val1'])
assert await cfg.option('choice').owner.get() == owner
cfg.option('choice').value.set(['val1'])
assert cfg.option('choice').owner.get() == owner
#
await cfg.option('choice').value.reset()
assert await cfg.option('choice').owner.isdefault()
cfg.option('choice').value.reset()
assert cfg.option('choice').owner.isdefault()
#
with pytest.raises(ValueError):
await cfg.option('choice').value.set('no')
assert await cfg.option('choice').owner.isdefault()
with raises(ValueError):
cfg.option('choice').value.set('no')
assert cfg.option('choice').owner.isdefault()
#
with pytest.raises(ValueError):
await cfg.option('ch2').value.get()
assert not await list_sessions()
with raises(ValueError):
cfg.option('ch2').value.get()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choiceoption_calc_opt_multi_function_kwargs(config_type):
def test_choiceoption_calc_opt_multi_function_kwargs(config_type):
str_ = StrOption('str', '', ['val1'], multi=True)
choice = ChoiceOption('choice',
"",
@ -231,46 +220,45 @@ async def test_choiceoption_calc_opt_multi_function_kwargs(config_type):
default=['val2'],
values=Calculation(return_val, Params(kwargs={'val': ParamOption(str_)})),
multi=True)
odesc = OptionDescription('od', '', [str_, choice, ch2])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
# FIXME cfg = await get_config(cfg, config_type)
assert await cfg.option('choice').owner.isdefault()
assert await cfg.option('choice').value.get() == []
od1 = OptionDescription('od', '', [str_, choice, ch2])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
# FIXME cfg = get_config(cfg, config_type)
assert cfg.option('choice').owner.isdefault()
assert cfg.option('choice').value.get() == []
#
await cfg.option('choice').value.set(['val1'])
assert await cfg.option('choice').owner.get() == owner
cfg.option('choice').value.set(['val1'])
assert cfg.option('choice').owner.get() == owner
#
with pytest.raises(ValueError):
await cfg.option('choice').value.set([undefined])
with raises(ValueError):
cfg.option('choice').value.set([undefined])
#
await cfg.option('choice').value.set(['val1'])
assert await cfg.option('choice').owner.get() == owner
cfg.option('choice').value.set(['val1'])
assert cfg.option('choice').owner.get() == owner
#
await cfg.option('choice').value.reset()
assert await cfg.option('choice').owner.isdefault()
cfg.option('choice').value.reset()
assert cfg.option('choice').owner.isdefault()
#
with pytest.raises(ValueError):
await cfg.option('choice').value.set('no')
assert await cfg.option('choice').owner.isdefault()
with raises(ValueError):
cfg.option('choice').value.set('no')
assert cfg.option('choice').owner.isdefault()
#
with pytest.raises(ValueError):
await cfg.option('ch2').value.get()
assert not await list_sessions()
with raises(ValueError):
cfg.option('ch2').value.get()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choiceoption_calc_not_list():
def test_choiceoption_calc_not_list():
str_ = StrOption('str', '', 'val1')
choice = ChoiceOption('choice',
"",
default_multi='val2',
values=Calculation(return_val, Params(ParamOption(str_))),
multi=True)
odesc = OptionDescription('od', '', [str_, choice])
async with await Config(odesc) as cfg:
await cfg.property.read_write()
with pytest.raises(ConfigError):
await cfg.option('choice').value.set(['val1'])
assert not await list_sessions()
od1 = OptionDescription('od', '', [str_, choice])
cfg = Config(od1)
cfg.property.read_write()
with raises(ConfigError):
cfg.option('choice').value.set(['val1'])
# assert not list_sessions()

508
tests/test_config.py
View file

@ -6,16 +6,15 @@ import weakref
from .autopath import do_autopath
do_autopath()
from .config import config_type, get_config, value_list, global_owner, event_loop
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, delete_session
BoolOption, StrOption, SymLinkOption, OptionDescription, undefined
from tiramisu.error import ConflictError, ConfigError, PropertiesOptionError, APIError
from tiramisu.storage import list_sessions
def make_description():
@ -41,203 +40,193 @@ def make_description():
return descr
@pytest.mark.asyncio
async def test_base_config(config_type):
def test_base_config(config_type):
"""making a :class:`tiramisu.config.Config()` object
and a :class:`tiramisu.option.OptionDescription()` object
"""
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('dummy').value.get() is False
#dmo = await cfg.unwrap_from_path('dummy')
#assert dmo.impl_getname() == 'dummy'
assert not await list_sessions()
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.config.type() == 'config'
@pytest.mark.asyncio
async def test_base_config_name():
def test_base_config_name():
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr, session_id='cfg') as cfg:
await cfg.session.id() == 'cfg'
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg = Config(od1)
#raises(ValueError, "Config(descr, session_id='unvalid name')")
assert not await list_sessions()
#
#
#@pytest.mark.asyncio
#async def test_not_config():
# assert raises(TypeError, "Config('str')")
# assert not list_sessions()
@pytest.mark.asyncio
async def test_base_path():
def test_base_path():
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg:
base = OptionDescription('config', '', [descr])
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg = Config(od1)
base = OptionDescription('config', '', [od1])
with pytest.raises(ConfigError):
async with await Config(base, session_id='error'):
with Config(base):
pass
await delete_session('error')
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_base_config_force_permissive():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.permissive.add('hidden')
def test_base_config_force_permissive():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
cfg.permissive.add('hidden')
with pytest.raises(PropertiesOptionError):
await cfg.option('boolop').value.get()
assert await cfg.forcepermissive.option('boolop').value.get() is True
assert not await list_sessions()
cfg.option('boolop').value.get()
assert cfg.forcepermissive.option('boolop').value.get() is True
# assert not list_sessions()
@pytest.mark.asyncio
async def test_base_config_in_a_tree():
def test_base_config_in_a_tree():
# FIXME
config_type = 'tiramisu'
"how options are organized into a tree, see :ref:`tree`"
descr = make_description()
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
od1 = make_description()
cfg = Config(od1)
cfg = get_config(cfg, config_type)
#
await cfg.option('bool').value.set(False)
cfg.option('bool').value.set(False)
#
assert await cfg.option('gc.name').value.get() == 'ref'
await cfg.option('gc.name').value.set('framework')
assert await cfg.option('gc.name').value.get() == 'framework'
assert cfg.option('gc.name').value.get() == 'ref'
cfg.option('gc.name').value.set('framework')
assert cfg.option('gc.name').value.get() == 'framework'
#
assert await cfg.option('objspace').value.get() == 'std'
await cfg.option('objspace').value.set('thunk')
assert await cfg.option('objspace').value.get() == 'thunk'
assert cfg.option('objspace').value.get() == 'std'
cfg.option('objspace').value.set('thunk')
assert cfg.option('objspace').value.get() == 'thunk'
#
assert await cfg.option('gc.float').value.get() == 2.3
await cfg.option('gc.float').value.set(3.4)
assert await cfg.option('gc.float').value.get() == 3.4
assert cfg.option('gc.float').value.get() == 2.3
cfg.option('gc.float').value.set(3.4)
assert cfg.option('gc.float').value.get() == 3.4
#
assert await cfg.option('int').value.get() == 0
await cfg.option('int').value.set(123)
assert await cfg.option('int').value.get() == 123
assert cfg.option('int').value.get() == 0
cfg.option('int').value.set(123)
assert cfg.option('int').value.get() == 123
#
assert await cfg.option('wantref').value.get() is False
await cfg.option('wantref').value.set(True)
assert await cfg.option('wantref').value.get() is True
assert cfg.option('wantref').value.get() is False
cfg.option('wantref').value.set(True)
assert cfg.option('wantref').value.get() is True
#
assert await cfg.option('str').value.get() == 'abc'
await cfg.option('str').value.set('def')
assert await cfg.option('str').value.get() == 'def'
assert cfg.option('str').value.get() == 'abc'
cfg.option('str').value.set('def')
assert cfg.option('str').value.get() == 'def'
#
with pytest.raises(AttributeError):
await cfg.option('gc.foo').value.get()
cfg.option('gc.foo').value.get()
##
async with await Config(descr) as cfg:
assert await cfg.option('bool').value.get() is True
assert await cfg.option('gc.name').value.get() == 'ref'
assert await cfg.option('wantframework').value.get() is False
assert not await list_sessions()
cfg = Config(od1)
assert cfg.option('bool').value.get() is True
assert cfg.option('gc.name').value.get() == 'ref'
assert cfg.option('wantframework').value.get() is False
# assert not list_sessions()
@pytest.mark.asyncio
async def test_not_valid_properties():
def test_not_valid_properties():
with pytest.raises(AssertionError):
stroption = StrOption('str', 'Test string option', default='abc', properties='mandatory')
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_information_config():
descr = make_description()
async with await Config(descr) as cfg:
def test_information_config():
od1 = make_description()
cfg = Config(od1)
string = 'some informations'
#
assert list(await cfg.information.list()) == ['doc']
await cfg.information.set('info', string)
assert await cfg.information.get('info') == string
assert set(await cfg.information.list()) == {'doc', 'info'}
assert list(cfg.information.list()) == ['doc']
cfg.information.set('info', string)
assert cfg.information.get('info') == string
assert set(cfg.information.list()) == {'doc', 'info'}
#
with pytest.raises(ValueError):
await cfg.information.get('noinfo')
assert await cfg.information.get('noinfo', 'default') == 'default'
await cfg.information.reset('info')
cfg.information.get('noinfo')
assert cfg.information.get('noinfo', 'default') == 'default'
cfg.information.reset('info')
with pytest.raises(ValueError):
await cfg.information.get('info')
cfg.information.get('info')
with pytest.raises(ValueError):
await cfg.information.reset('noinfo')
assert list(await cfg.information.list()) == ['doc']
assert not await list_sessions()
cfg.information.reset('noinfo')
assert list(cfg.information.list()) == ['doc']
# assert not list_sessions()
@pytest.mark.asyncio
async def test_information_option():
descr = make_description()
async with await Config(descr) as cfg:
def test_information_exportation():
od1 = make_description()
cfg = Config(od1)
string = 'some informations'
cfg.information.set('info', string)
#
assert cfg.information.exportation() == {None: {'info': string}}
def test_information_importation():
od1 = make_description()
cfg = Config(od1)
string = 'some informations'
assert cfg.information.exportation() == {}
#
cfg.information.importation({None: {'info': string}})
assert cfg.information.exportation() == {None: {'info': string}}
def test_information_option():
od1 = make_description()
cfg = Config(od1)
string = 'some informations'
#
assert list(await cfg.option('gc.name').information.list()) == ['doc']
await cfg.option('gc.name').information.set('info', string)
assert await cfg.option('gc.name').information.get('info') == string
assert set(await cfg.option('gc.name').information.list()) == {'doc', 'info'}
assert list(cfg.option('gc.name').information.list()) == ['doc']
cfg.option('gc.name').information.set('info', string)
assert cfg.option('gc.name').information.get('info') == string
assert set(cfg.option('gc.name').information.list()) == {'doc', 'info'}
#
with pytest.raises(ValueError):
await cfg.option('gc.name').information.get('noinfo')
assert await cfg.option('gc.name').information.get('noinfo', 'default') == 'default'
await cfg.option('gc.name').information.reset('info')
cfg.option('gc.name').information.get('noinfo')
assert cfg.option('gc.name').information.get('noinfo', 'default') == 'default'
cfg.option('gc.name').information.reset('info')
with pytest.raises(ValueError):
await cfg.option('gc.name').information.get('info')
cfg.option('gc.name').information.get('info')
with pytest.raises(ValueError):
await cfg.option('gc.name').information.reset('noinfo')
assert list(await cfg.option('gc.name').information.list()) == ['doc']
cfg.option('gc.name').information.reset('noinfo')
assert list(cfg.option('gc.name').information.list()) == ['doc']
#
assert await cfg.option('wantref').information.get('info') == 'default value'
await cfg.option('wantref').information.set('info', 'default value')
assert await cfg.option('wantref').information.get('info') == 'default value'
await cfg.option('wantref').information.reset('info')
assert await cfg.option('wantref').information.get('info') == 'default value'
assert not await list_sessions()
assert cfg.option('wantref').information.get('info') == 'default value'
cfg.option('wantref').information.set('info', 'default value')
assert cfg.option('wantref').information.get('info') == 'default value'
cfg.option('wantref').information.reset('info')
assert cfg.option('wantref').information.get('info') == 'default value'
# assert not list_sessions()
@pytest.mark.asyncio
async def test_information_optiondescription():
descr = make_description()
async with await Config(descr) as cfg:
def test_information_optiondescription():
od1 = make_description()
cfg = Config(od1)
string = 'some informations'
#
assert list(await cfg.option('gc').information.list()) == ['doc']
await cfg.option('gc').information.set('info', string)
assert await cfg.option('gc').information.get('info') == string
assert set(await cfg.option('gc').information.list()) == {'doc', 'info'}
assert list(cfg.option('gc').information.list()) == ['doc']
cfg.option('gc').information.set('info', string)
assert cfg.option('gc').information.get('info') == string
assert set(cfg.option('gc').information.list()) == {'doc', 'info'}
#
with pytest.raises(ValueError):
await cfg.option('gc').information.get('noinfo')
assert await cfg.option('gc').information.get('noinfo', 'default') == 'default'
await cfg.option('gc').information.reset('info')
cfg.option('gc').information.get('noinfo')
assert cfg.option('gc').information.get('noinfo', 'default') == 'default'
cfg.option('gc').information.reset('info')
with pytest.raises(ValueError):
await cfg.option('gc').information.get('info')
cfg.option('gc').information.get('info')
with pytest.raises(ValueError):
await cfg.option('gc').information.reset('noinfo')
assert list(await cfg.option('gc').information.list()) == ['doc']
assert not await list_sessions()
cfg.option('gc').information.reset('noinfo')
assert list(cfg.option('gc').information.list()) == ['doc']
# assert not list_sessions()
def compare(val1, val2):
assert len(val1[0]) == len(val2[0])
for idx1, val_1 in enumerate(val1[0]):
idx2 = val2[0].index(val_1)
assert val1[0][idx1] == val2[0][idx2]
assert val1[1][idx1] == val2[1][idx2]
if isinstance(val2[2][idx2], tuple):
assert val2[2][idx2] == tuple(val1[2][idx1])
else:
assert val2[2][idx2] == val1[2][idx1]
assert val1[3][idx1] == val2[3][idx2]
assert val1 == val2
@pytest.mark.asyncio
async def test_get_modified_values():
def test_get_modified_values():
g1 = IntOption('g1', '', 1)
g2 = StrOption('g2', '', 'héhé')
g3 = StrOption('g3', '', 'héhé')
@ -245,211 +234,188 @@ async def test_get_modified_values():
g5 = StrOption('g5', '')
g6 = StrOption('g6', '', multi=True)
d1 = OptionDescription('od', '', [g1, g2, g3, g4, g5, g6])
root = OptionDescription('root', '', [d1])
async with await Config(root) as cfg:
compare(await cfg.value.exportation(), ((), (), (), ()))
assert not await cfg.option('od.g5').option.ismulti()
assert not await cfg.option('od.g5').option.issubmulti()
await cfg.option('od.g5').value.set('yes')
compare(await cfg.value.exportation(), (('od.g5',), (None,), ('yes',), ('user',)))
await cfg.option('od.g4').value.set(False)
compare(await cfg.value.exportation(), (('od.g5', 'od.g4'), (None, None), ('yes', False), ('user', 'user')))
await cfg.option('od.g4').value.set(undefined)
compare(await cfg.value.exportation(), (('od.g5', 'od.g4'), (None, None), ('yes', True), ('user', 'user')))
await cfg.option('od.g4').value.reset()
compare(await cfg.value.exportation(), (('od.g5',), (None,), ('yes',), ('user',)))
assert await cfg.option('od.g6').option.ismulti()
await cfg.option('od.g6').value.set([undefined])
compare(await cfg.value.exportation(), (('od.g5', 'od.g6'), (None, None), ('yes', (None,)), ('user', 'user')))
await cfg.option('od.g6').value.set([])
compare(await cfg.value.exportation(), (('od.g5', 'od.g6'), (None, None), ('yes', tuple()), ('user', 'user')))
await cfg.option('od.g6').value.set(['3'])
compare(await cfg.value.exportation(), (('od.g5', 'od.g6'), (None, None), ('yes', ('3',)), ('user', 'user')))
await cfg.option('od.g6').value.set([])
compare(await cfg.value.exportation(), (('od.g5', 'od.g6'), (None, None), ('yes', tuple()), ('user', 'user')))
assert not await list_sessions()
od1 = OptionDescription('root', '', [d1])
cfg = Config(od1)
compare(cfg.value.exportation(), {})
assert not cfg.option('od.g5').option.ismulti()
assert not cfg.option('od.g5').option.issubmulti()
cfg.option('od.g5').value.set('yes')
compare(cfg.value.exportation(), {'od.g5': {None: ['yes', 'user']}})
cfg.option('od.g4').value.set(False)
compare(cfg.value.exportation(), {'od.g5': {None: ['yes', 'user']}, 'od.g4': {None: [False, 'user']}})
cfg.option('od.g4').value.set(undefined)
compare(cfg.value.exportation(), {'od.g5': {None: ['yes', 'user']}, 'od.g4': {None: [True, 'user']}})
cfg.option('od.g4').value.reset()
compare(cfg.value.exportation(), {'od.g5': {None: ['yes', 'user']}})
assert cfg.option('od.g6').option.ismulti()
cfg.option('od.g6').value.set([undefined])
compare(cfg.value.exportation(), {'od.g5': {None: ['yes', 'user']}, 'od.g6': {None: [[None], 'user']}})
cfg.option('od.g6').value.set([])
compare(cfg.value.exportation(), {'od.g5': {None: ['yes', 'user']}, 'od.g6': {None: [[], 'user']}})
cfg.option('od.g6').value.set(['3'])
compare(cfg.value.exportation(), {'od.g5': {None: ['yes', 'user']}, 'od.g6': {None: [['3'], 'user']}})
cfg.option('od.g6').value.set([])
compare(cfg.value.exportation(), {'od.g5': {None: ['yes', 'user']}, 'od.g6': {None: [[], 'user']}})
# assert not list_sessions()
@pytest.mark.asyncio
async def test_get_modified_values_not_modif(config_type):
def test_get_modified_values_not_modif(config_type):
g1 = StrOption('g1', '', multi=True)
d1 = OptionDescription('od', '', [g1])
root = OptionDescription('root', '', [d1])
async with await Config(root) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('od.g1').value.get() == []
value = await cfg.option('od.g1').value.get()
od1 = OptionDescription('root', '', [d1])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('od.g1').value.get() == []
value = cfg.option('od.g1').value.get()
value.append('val')
assert await cfg.option('od.g1').value.get() == []
assert not await list_sessions()
assert cfg.option('od.g1').value.get() == []
# assert not list_sessions()
@pytest.mark.asyncio
async def test_duplicated_option():
def test_duplicated_option():
g1 = IntOption('g1', '', 1)
g1
#in same OptionDescription
with pytest.raises(ConflictError):
d1 = OptionDescription('od', '', [g1, g1])
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_duplicated_option_diff_od():
def test_duplicated_option_diff_od():
g1 = IntOption('g1', '', 1)
d1 = OptionDescription('od1', '', [g1])
#in different OptionDescription
d2 = OptionDescription('od2', '', [g1, d1])
d2
with pytest.raises(ConflictError):
await Config(d2, session_id='error')
await delete_session('error')
assert not await list_sessions()
Config(d2)
@pytest.mark.asyncio
async def test_cannot_assign_value_to_option_description():
descr = make_description()
async with await Config(descr) as cfg:
def test_cannot_assign_value_to_option_description():
od1 = make_description()
cfg = Config(od1)
with pytest.raises(APIError):
await cfg.option('gc').value.set(3)
assert not await list_sessions()
cfg.option('gc').value.set(3)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_config_multi(config_type):
def test_config_multi(config_type):
i1 = IntOption('test1', '', multi=True)
i2 = IntOption('test2', '', multi=True, default_multi=1)
i3 = IntOption('test3', '', default=[2], multi=True, default_multi=1)
od = OptionDescription('test', '', [i1, i2, i3])
async with await Config(od) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('test1').value.get() == []
assert await cfg.option('test2').value.get() == []
await cfg.option('test2').value.set([undefined])
assert await cfg.option('test2').value.get() == [1]
assert await cfg.option('test3').value.get() == [2]
await cfg.option('test3').value.set([undefined, undefined])
assert await cfg.option('test3').value.get() == [2, 1]
assert not await list_sessions()
od1 = OptionDescription('test', '', [i1, i2, i3])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('test1').value.get() == []
assert cfg.option('test2').value.get() == []
cfg.option('test2').value.set([undefined])
assert cfg.option('test2').value.get() == [1]
assert cfg.option('test3').value.get() == [2]
cfg.option('test3').value.set([undefined, undefined])
assert cfg.option('test3').value.get() == [2, 1]
# assert not list_sessions()
@pytest.mark.asyncio
async def test_prefix_error():
def test_prefix_error():
i1 = IntOption('test1', '')
od = OptionDescription('test', '', [i1])
async with await Config(od) as cfg:
await cfg.property.read_write()
await cfg.option('test1').value.set(1)
od1 = OptionDescription('test', '', [i1])
cfg = Config(od1)
cfg.property.read_write()
cfg.option('test1').value.set(1)
try:
await cfg.option('test1').value.set('yes')
cfg.option('test1').value.set('yes')
except Exception as err:
assert str(err) == _('"{0}" is an invalid {1} for "{2}"').format('yes', _('integer'), 'test1')
try:
await cfg.option('test1').value.set('yes')
cfg.option('test1').value.set('yes')
except Exception as err:
err.prefix = ''
assert str(err) == _('invalid value')
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_no_validation():
def test_no_validation():
# FIXME
config_type = 'tiramisu'
i1 = IntOption('test1', '')
od = OptionDescription('test', '', [i1])
async with await Config(od) as config:
await config.property.read_write()
cfg = await get_config(config, config_type)
await cfg.option('test1').value.set(1)
od1 = OptionDescription('test', '', [i1])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
cfg.option('test1').value.set(1)
with pytest.raises(ValueError):
await cfg.option('test1').value.set('yes')
assert await cfg.option('test1').value.get() == 1
await config.property.pop('validator')
cfg = await get_config(config, config_type)
await cfg.option('test1').value.set('yes')
assert await cfg.option('test1').value.get() == 'yes'
await cfg.property.add('validator')
cfg.option('test1').value.set('yes')
assert cfg.option('test1').value.get() == 1
cfg.property.remove('validator')
cfg = get_config(cfg, config_type)
cfg.option('test1').value.set('yes')
assert cfg.option('test1').value.get() == 'yes'
cfg.property.add('validator')
with pytest.raises(ValueError):
await cfg.option('test1').value.get()
await cfg.option('test1').value.reset()
assert await cfg.option('test1').value.get() is None
assert not await list_sessions()
cfg.option('test1').value.get()
cfg.option('test1').value.reset()
assert cfg.option('test1').value.get() is None
# assert not list_sessions()
@pytest.mark.asyncio
async def test_subconfig():
i = IntOption('i', '')
o = OptionDescription('val', '', [i])
o2 = OptionDescription('val', '', [o])
async with await Config(o2) as cfg:
cfg
with pytest.raises(TypeError):
await SubConfig(i, weakref.ref(cfg))
assert not await list_sessions()
#def test_subconfig():
# i = IntOption('i', '')
# o = OptionDescription('val', '', [i])
# od1 = OptionDescription('val', '', [o])
# cfg = Config(od1)
# cfg
# with pytest.raises(TypeError):
# SubConfig(i, weakref.ref(cfg))
# assert not list_sessions()
@pytest.mark.asyncio
async def test_config_subconfig():
def test_config_subconfig():
i1 = IntOption('i1', '')
i2 = IntOption('i2', '', default=1)
i3 = IntOption('i3', '')
i4 = IntOption('i4', '', default=2)
od1 = OptionDescription('od1', '', [i1, i2, i3, i4])
od2 = OptionDescription('od2', '', [od1])
async with await Config(od2, session_id='conf1') as cfg:
cfg = Config(od2)
with pytest.raises(ConfigError):
conf2 = await Config(od1, session_id='conf2')
await delete_session('conf2')
assert not await list_sessions()
cfg2 = Config(od1)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_config_invalidsession():
i = IntOption('i', '')
o = OptionDescription('val', '', [i])
o2 = OptionDescription('val', '', [o])
with pytest.raises(ValueError):
await Config(o2, session_id=2)
assert not await list_sessions()
@pytest.mark.asyncio
async def test_config_od_name(config_type):
def test_config_od_name(config_type):
i = IntOption('i', '')
s = SymLinkOption('s', i)
o = OptionDescription('val', '', [i, s])
o2 = OptionDescription('val', '', [o])
async with await Config(o2) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('val.i').option.name() == 'i'
assert await cfg.option('val.s').option.name() == 's'
assert await cfg.option('val.s').option.name(follow_symlink=True) == 'i'
assert not await list_sessions()
cfg = Config(o2)
cfg = get_config(cfg, config_type)
assert cfg.option('val.i').option.name() == 'i'
assert cfg.option('val.s').option.name() == 's'
assert cfg.option('val.s').option.name(follow_symlink=True) == 'i'
assert cfg.option('val.s').option.type() == 'integer'
assert cfg.option('val').option.type() == 'optiondescription'
# assert not list_sessions()
@pytest.mark.asyncio
async def test_config_od_type(config_type):
def test_config_od_type(config_type):
i = IntOption('i', '')
o = OptionDescription('val', '', [i])
o2 = OptionDescription('val', '', [o])
async with await Config(o2) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('val').option.type() == 'optiondescription'
assert await cfg.option('val.i').option.type() == 'integer'
assert not await list_sessions()
cfg = Config(o2)
cfg = get_config(cfg, config_type)
assert cfg.option('val').option.type() == 'optiondescription'
assert cfg.option('val.i').option.type() == 'integer'
# assert not list_sessions()
@pytest.mark.asyncio
async def test_config_default(config_type):
def test_config_default(config_type):
i = IntOption('i', '', 8)
o = OptionDescription('val', '', [i])
o2 = OptionDescription('val', '', [o])
async with await Config(o2) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('val.i').value.default() == 8
await cfg.option('val.i').value.set(9)
assert await cfg.option('val.i').value.get() == 9
assert await cfg.option('val.i').value.default() == 8
assert not await list_sessions()
cfg = Config(o2)
cfg = get_config(cfg, config_type)
assert cfg.option('val.i').value.default() == 8
cfg.option('val.i').value.set(9)
assert cfg.option('val.i').value.get() == 9
assert cfg.option('val.i').value.default() == 8
# assert not list_sessions()

515
tests/test_config_api.py
View file

@ -1,16 +1,15 @@
"configuration objects global API"
import pytest
from pytest import raises
from .autopath import do_autopath
do_autopath()
from .config import config_type, get_config, value_list, global_owner, event_loop
from .config import config_type, get_config, value_list, global_owner
from tiramisu import Config, IntOption, FloatOption, StrOption, ChoiceOption, \
BoolOption, FilenameOption, SymLinkOption, IPOption, \
PortOption, NetworkOption, NetmaskOption, BroadcastOption, \
DomainnameOption, OptionDescription
from tiramisu.error import PropertiesOptionError, ValueWarning
from tiramisu.storage import list_sessions
from tiramisu.error import PropertiesOptionError, ValueWarning, APIError
import warnings
@ -52,50 +51,75 @@ def _is_same_opt(opt1, opt2):
assert opt1 == opt2
@pytest.mark.asyncio
async def test_od_not_list():
def test_od_not_list():
b = BoolOption('bool', '', multi=True)
with pytest.raises(AssertionError):
with raises(AssertionError):
OptionDescription('od', '', b)
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_str():
descr = make_description()
async with await Config(descr) as cfg:
def test_str():
od1 = make_description()
cfg = Config(od1)
cfg # does not crash
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_make_dict(config_type):
def test_make_dict(config_type):
"serialization of the whole config to a dict"
descr = OptionDescription("opt", "", [
od1 = OptionDescription("opt", "", [
OptionDescription("s1", "", [
BoolOption("a", "", default=False),
BoolOption("b", "", default=False, properties=('hidden',))]),
IntOption("int", "", default=42)])
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.permissive.add('hidden')
cfg = await get_config(cfg, config_type)
d = await cfg.value.dict()
cfg = Config(od1)
cfg.property.read_write()
cfg.permissive.add('hidden')
cfg = get_config(cfg, config_type)
d = cfg.value.dict()
assert d == {"s1.a": False, "int": 42}
await cfg.option('int').value.set(43)
await cfg.option('s1.a').value.set(True)
d = await cfg.value.dict()
cfg.option('int').value.set(43)
cfg.option('s1.a').value.set(True)
d = cfg.value.dict()
assert d == {"s1.a": True, "int": 43}
d2 = await cfg.value.dict(flatten=True)
d2 = cfg.value.dict(flatten=True)
assert d2 == {'a': True, 'int': 43}
if config_type == 'tiramisu':
assert await cfg.forcepermissive.value.dict() == {"s1.a": True, "s1.b": False, "int": 43}
assert not await list_sessions()
assert cfg.forcepermissive.value.dict() == {"s1.a": True, "s1.b": False, "int": 43}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_make_dict_with_disabled(config_type):
descr = OptionDescription("opt", "", [
def test_make_dict_sub(config_type):
"serialization part of config to a dict"
od1 = OptionDescription("opt", "", [
OptionDescription("s1", "", [
BoolOption("a", "", default=False),
BoolOption("b", "", default=False, properties=('hidden',))]),
IntOption("int", "", default=42)])
cfg = Config(od1)
cfg.property.read_write()
cfg.permissive.add('hidden')
cfg = get_config(cfg, config_type)
assert cfg.option('s1').value.dict() == {'a': False}
def test_make_dict_not_value(config_type):
"serialization part of config to a dict"
od1 = OptionDescription("opt", "", [
OptionDescription("s1", "", [
BoolOption("a", "", default=False),
BoolOption("b", "", default=False, properties=('hidden',))]),
IntOption("int", "", default=42)])
cfg = Config(od1)
cfg.property.read_write()
cfg.permissive.add('hidden')
cfg = get_config(cfg, config_type)
with raises(APIError):
cfg.option('s1.a').value.dict()
def test_make_dict_with_disabled(config_type):
od1 = OptionDescription("opt", "", [
OptionDescription("s1", "", [
BoolOption("a", "", default=False),
BoolOption("b", "", default=False, properties=('disabled',))]),
@ -103,19 +127,18 @@ async def test_make_dict_with_disabled(config_type):
BoolOption("a", "", default=False),
BoolOption("b", "", default=False)], properties=('disabled',)),
IntOption("int", "", default=42)])
async with await Config(descr) as cfg:
await cfg.property.read_only()
cfg = await get_config(cfg, config_type)
assert await cfg.value.dict() == {"s1.a": False, "int": 42}
cfg = Config(od1)
cfg.property.read_only()
cfg = get_config(cfg, config_type)
assert cfg.value.dict() == {"s1.a": False, "int": 42}
if config_type == 'tiramisu':
assert await cfg.forcepermissive.value.dict() == {"s1.a": False, "int": 42}
assert await cfg.unrestraint.value.dict() == {"int": 42, "s1.a": False, "s1.b": False, "s2.a": False, "s2.b": False}
assert not await list_sessions()
assert cfg.forcepermissive.value.dict() == {"s1.a": False, "int": 42}
assert cfg.unrestraint.value.dict() == {"int": 42, "s1.a": False, "s1.b": False, "s2.a": False, "s2.b": False}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_make_dict_with_disabled_in_callback(config_type):
descr = OptionDescription("opt", "", [
def test_make_dict_with_disabled_in_callback(config_type):
od1 = OptionDescription("opt", "", [
OptionDescription("s1", "", [
BoolOption("a", "", default=False),
BoolOption("b", "", default=False, properties=('disabled',))]),
@ -123,17 +146,16 @@ async def test_make_dict_with_disabled_in_callback(config_type):
BoolOption("a", "", default=False),
BoolOption("b", "", default=False)], properties=('disabled',)),
IntOption("int", "", default=42)])
async with await Config(descr) as cfg:
await cfg.property.read_only()
cfg = await get_config(cfg, config_type)
d = await cfg.value.dict()
cfg = Config(od1)
cfg.property.read_only()
cfg = get_config(cfg, config_type)
d = cfg.value.dict()
assert d == {"s1.a": False, "int": 42}
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_make_dict_fullpath(config_type):
descr = OptionDescription("root", "", [
def test_make_dict_fullpath(config_type):
od1 = OptionDescription("root", "", [
OptionDescription("opt", "", [
OptionDescription("s1", "", [
BoolOption("a", "", default=False),
@ -143,328 +165,309 @@ async def test_make_dict_fullpath(config_type):
BoolOption("b", "", default=False)], properties=('disabled',)),
IntOption("int", "", default=42)]),
IntOption("introot", "", default=42)])
async with await Config(descr) as cfg:
await cfg.property.read_only()
cfg = await get_config(cfg, config_type)
assert await cfg.value.dict() == {"opt.s1.a": False, "opt.int": 42, "introot": 42}
cfg = Config(od1)
cfg.property.read_only()
cfg = get_config(cfg, config_type)
assert cfg.value.dict() == {"opt.s1.a": False, "opt.int": 42, "introot": 42}
if config_type == 'tiramisu':
# FIXME
assert await cfg.option('opt').value.dict() == {"s1.a": False, "int": 42}
assert await cfg.value.dict(fullpath=True) == {"opt.s1.a": False, "opt.int": 42, "introot": 42}
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 await cfg.option('opt').value.dict(fullpath=True) == {"opt.s1.a": False, "opt.int": 42}
assert not await list_sessions()
assert cfg.option('opt').value.dict(fullpath=True) == {"opt.s1.a": False, "opt.int": 42}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_find_in_config():
def test_find_in_config():
"finds option in config"
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_only()
await cfg.permissive.add('hidden')
ret = list(await cfg.option.find('dummy'))
od1 = make_description()
cfg = Config(od1)
cfg.property.read_only()
cfg.permissive.add('hidden')
ret = list(cfg.option.find('dummy'))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), await cfg.option('gc.dummy').option.get())
_is_same_opt(ret[0].option.get(), cfg.option('gc.dummy').option.get())
#
ret_find = await cfg.option.find('dummy', first=True)
ret = await ret_find.option.get()
_is_same_opt(ret, await cfg.option('gc.dummy').option.get())
ret_find = cfg.option.find('dummy', first=True)
ret = ret_find.option.get()
_is_same_opt(ret, cfg.option('gc.dummy').option.get())
#
ret = list(await cfg.option.find('float'))
ret = list(cfg.option.find('float'))
assert len(ret) == 2
_is_same_opt(await ret[0].option.get(), await cfg.option('gc.float').option.get())
_is_same_opt(await ret[1].option.get(), await cfg.option('float').option.get())
_is_same_opt(ret[0].option.get(), cfg.option('gc.float').option.get())
_is_same_opt(ret[1].option.get(), cfg.option('float').option.get())
#
ret = await cfg.option.find('bool', first=True)
_is_same_opt(await ret.option.get(), await cfg.option('gc.gc2.bool').option.get())
ret = await cfg.option.find('bool', value=True, first=True)
_is_same_opt(await ret.option.get(), await cfg.option('bool').option.get())
ret = await cfg.option.find('dummy', first=True)
_is_same_opt(await ret.option.get(), await cfg.option('gc.dummy').option.get())
ret = await cfg.option.find('float', first=True)
_is_same_opt(await ret.option.get(), await cfg.option('gc.float').option.get())
#FIXME cannot find an option without name
#ret = await cfg.find(bytype=ChoiceOption)
#assert len(ret) == 2
#_is_same_opt(ret[0], await cfg.unwrap_from_path('gc.name'))
#_is_same_opt(ret[1], await cfg.unwrap_from_path('objspace'))
#
#_is_same_opt(await cfg.find_first(bytype=ChoiceOption), await cfg.unwrap_from_path('gc.name'))
#ret = await cfg.find(byvalue='ref')
#assert len(ret) == 1
#_is_same_opt(ret[0], await cfg.unwrap_from_path('gc.name'))
#_is_same_opt(await cfg.find_first(byvalue='ref'), await cfg.unwrap_from_path('gc.name'))
#
ret = list(await cfg.option.find('prop'))
ret = cfg.option.find('bool', first=True)
_is_same_opt(ret.option.get(), cfg.option('gc.gc2.bool').option.get())
ret = cfg.option.find('bool', value=True, first=True)
_is_same_opt(ret.option.get(), cfg.option('bool').option.get())
ret = cfg.option.find('dummy', first=True)
_is_same_opt(ret.option.get(), cfg.option('gc.dummy').option.get())
ret = cfg.option.find('float', first=True)
_is_same_opt(ret.option.get(), cfg.option('gc.float').option.get())
ret = list(cfg.option.find('prop'))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), await cfg.option('gc.prop').option.get())
_is_same_opt(ret[0].option.get(), cfg.option('gc.prop').option.get())
#
ret = list(await cfg.option.find('prop', value=None))
ret = list(cfg.option.find('prop', value=None))
assert len(ret) == 1
ret = list(await cfg.option.find('prop'))
ret = list(cfg.option.find('prop'))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), await cfg.option('gc.prop').option.get())
_is_same_opt(ret[0].option.get(), cfg.option('gc.prop').option.get())
#
await cfg.property.read_write()
with pytest.raises(AttributeError):
ret = await cfg.option.find('prop')
assert await ret.option.get()
ret = list(await cfg.unrestraint.option.find(name='prop'))
cfg.property.read_write()
with raises(AttributeError):
ret = cfg.option.find('prop')
assert ret.option.get()
ret = list(cfg.unrestraint.option.find(name='prop'))
assert len(ret) == 2
_is_same_opt(await ret[0].option.get(), await cfg.unrestraint.option('gc.gc2.prop').option.get())
_is_same_opt(await ret[1].option.get(), await cfg.forcepermissive.option('gc.prop').option.get())
_is_same_opt(ret[0].option.get(), cfg.unrestraint.option('gc.gc2.prop').option.get())
_is_same_opt(ret[1].option.get(), cfg.forcepermissive.option('gc.prop').option.get())
#
ret = list(await cfg.forcepermissive.option.find('prop'))
ret = list(cfg.forcepermissive.option.find('prop'))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), await cfg.forcepermissive.option('gc.prop').option.get())
_is_same_opt(ret[0].option.get(), cfg.forcepermissive.option('gc.prop').option.get())
#
ret = await cfg.forcepermissive.option.find('prop', first=True)
_is_same_opt(await ret.option.get(), await cfg.forcepermissive.option('gc.prop').option.get())
ret = cfg.forcepermissive.option.find('prop', first=True)
_is_same_opt(ret.option.get(), cfg.forcepermissive.option('gc.prop').option.get())
# combinaison of filters
ret = list(await cfg.unrestraint.option.find('prop', type=BoolOption))
ret = list(cfg.unrestraint.option.find('prop', type=BoolOption))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), await cfg.unrestraint.option('gc.gc2.prop').option.get())
ret = await cfg.unrestraint.option.find('prop', type=BoolOption, first=True)
_is_same_opt(await ret.option.get(), await cfg.unrestraint.option('gc.gc2.prop').option.get())
_is_same_opt(ret[0].option.get(), cfg.unrestraint.option('gc.gc2.prop').option.get())
ret = cfg.unrestraint.option.find('prop', type=BoolOption, first=True)
_is_same_opt(ret.option.get(), cfg.unrestraint.option('gc.gc2.prop').option.get())
#
ret = list(await cfg.option.find('dummy', value=False))
ret = list(cfg.option.find('dummy', value=False))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), await cfg.option('gc.dummy').option.get())
_is_same_opt(ret[0].option.get(), cfg.option('gc.dummy').option.get())
#
ret = await cfg.option.find('dummy', value=False, first=True)
_is_same_opt(await ret.option.get(), await cfg.option('gc.dummy').option.get())
ret = cfg.option.find('dummy', value=False, first=True)
_is_same_opt(ret.option.get(), cfg.option('gc.dummy').option.get())
#subcfgig
ret = list(await cfg.option('gc').find('dummy'))
ret = list(cfg.option('gc').find('dummy'))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), await cfg.option('gc.dummy').option.get())
_is_same_opt(ret[0].option.get(), cfg.option('gc.dummy').option.get())
#
ret = list(await cfg.option('gc').find('float'))
ret = list(cfg.option('gc').find('float'))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), await cfg.option('gc.float').option.get())
_is_same_opt(ret[0].option.get(), cfg.option('gc.float').option.get())
#
ret = list(await cfg.option('gc').find('bool'))
ret = list(cfg.option('gc.gc2').find('bool'))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), await cfg.option('gc.gc2.bool').option.get())
ret = await cfg.option('gc').find('bool', value=False, first=True)
_is_same_opt(await ret.option.get(), await cfg.option('gc.gc2.bool').option.get())
_is_same_opt(ret[0].option.get(), cfg.option('gc.gc2.bool').option.get())
ret = cfg.option('gc').find('bool', value=False, first=True)
_is_same_opt(ret.option.get(), cfg.option('gc.gc2.bool').option.get())
#
with pytest.raises(AttributeError):
ret = await cfg.option('gc').find('bool', value=True, first=True)
assert await ret.option.get()
with raises(AttributeError):
ret = cfg.option('gc').find('bool', value=True, first=True)
assert ret.option.get()
#
with pytest.raises(AttributeError):
ret = await cfg.option('gc').find('wantref')
await ret.option.get()
with raises(AttributeError):
ret = cfg.option('gc').find('wantref')
ret.option.get()
#
ret = list(await cfg.unrestraint.option('gc').find('prop'))
ret = list(cfg.unrestraint.option('gc').find('prop'))
assert len(ret) == 2
_is_same_opt(await ret[0].option.get(), await cfg.unrestraint.option('gc.gc2.prop').option.get())
_is_same_opt(await ret[1].option.get(), await cfg.forcepermissive.option('gc.prop').option.get())
_is_same_opt(ret[0].option.get(), cfg.unrestraint.option('gc.gc2.prop').option.get())
_is_same_opt(ret[1].option.get(), cfg.forcepermissive.option('gc.prop').option.get())
#
await cfg.property.read_only()
ret = list(await cfg.option('gc').find('prop'))
cfg.property.read_only()
ret = list(cfg.option('gc').find('prop'))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), await cfg.option('gc.prop').option.get())
_is_same_opt(ret[0].option.get(), cfg.option('gc.prop').option.get())
# not OptionDescription
with pytest.raises(AttributeError):
await cfg.option.find('gc', first=True)
with pytest.raises(AttributeError):
await cfg.option.find('gc2', first=True)
assert not await list_sessions()
with raises(AttributeError):
cfg.option.find('gc', first=True)
with raises(AttributeError):
cfg.option.find('gc2', first=True)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_find_multi():
def test_find_multi():
b = BoolOption('bool', '', multi=True, properties=('notunique',))
o = OptionDescription('od', '', [b])
async with await Config(o) as cfg:
od1 = OptionDescription('od', '', [b])
cfg = Config(od1)
#
with pytest.raises(AttributeError):
list(await cfg.option.find('bool', value=True))
with pytest.raises(AttributeError):
list(await cfg.option.find('bool', value=True, first=True))
await cfg.option('bool').value.set([False])
with pytest.raises(AttributeError):
list(await cfg.option.find('bool', value=True))
with pytest.raises(AttributeError):
list(await cfg.option.find('bool', value=True, first=True))
await cfg.option('bool').value.set([False, False])
with pytest.raises(AttributeError):
list(await cfg.option.find('bool', value=True))
with pytest.raises(AttributeError):
list(await cfg.option.find('bool', value=True, first=True))
await cfg.option('bool').value.set([False, False, True])
ret = list(await cfg.option.find('bool', value=True))
with raises(AttributeError):
list(cfg.option.find('bool', value=True))
with raises(AttributeError):
list(cfg.option.find('bool', value=True, first=True))
cfg.option('bool').value.set([False])
with raises(AttributeError):
list(cfg.option.find('bool', value=True))
with raises(AttributeError):
list(cfg.option.find('bool', value=True, first=True))
cfg.option('bool').value.set([False, False])
with raises(AttributeError):
list(cfg.option.find('bool', value=True))
with raises(AttributeError):
list(cfg.option.find('bool', value=True, first=True))
cfg.option('bool').value.set([False, False, True])
ret = list(cfg.option.find('bool', value=True))
assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), b)
ret = await cfg.option.find('bool', value=True, first=True)
_is_same_opt(await ret.option.get(), b)
assert not await list_sessions()
_is_same_opt(ret[0].option.get(), b)
ret = cfg.option.find('bool', value=True, first=True)
_is_same_opt(ret.option.get(), b)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_does_not_find_in_config():
descr = make_description()
async with await Config(descr) as cfg:
with pytest.raises(AttributeError):
list(await cfg.option.find('IDontExist'))
assert not await list_sessions()
def test_does_not_find_in_config():
od1 = make_description()
cfg = Config(od1)
with raises(AttributeError):
list(cfg.option.find('IDontExist'))
# assert not list_sessions()
@pytest.mark.asyncio
async def test_filename(config_type):
def test_filename(config_type):
a = FilenameOption('a', '')
o = OptionDescription('o', '', [a])
async with await Config(o) as cfg:
# FIXME cfg = await get_config(cfg, config_type)
await cfg.option('a').value.set('/')
await cfg.option('a').value.set('/tmp')
await cfg.option('a').value.set('/tmp/')
await cfg.option('a').value.set('/tmp/text.txt')
await cfg.option('a').value.set('/tmp/with space.txt')
await cfg.option('a').value.set('/tmp/with$.txt')
with pytest.raises(ValueError):
await cfg.option('a').value.set('not starts with /')
assert not await list_sessions()
od1 = OptionDescription('o', '', [a])
cfg = Config(od1)
# FIXME cfg = get_config(cfg, config_type)
cfg.option('a').value.set('/')
cfg.option('a').value.set('/tmp')
cfg.option('a').value.set('/tmp/')
cfg.option('a').value.set('/tmp/text.txt')
cfg.option('a').value.set('/tmp/with space.txt')
cfg.option('a').value.set('/tmp/with$.txt')
with raises(ValueError):
cfg.option('a').value.set('not starts with /')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_invalid_option():
def test_invalid_option():
ChoiceOption('a', '', ('1', '2'))
with pytest.raises(TypeError):
with raises(TypeError):
ChoiceOption('a', '', [1, 2])
with pytest.raises(TypeError):
with raises(TypeError):
ChoiceOption('a', '', 1)
with pytest.raises(ValueError):
with raises(ValueError):
ChoiceOption('a', '', (1,), 3)
FloatOption('a', '')
with pytest.raises(ValueError):
with raises(ValueError):
FloatOption('a', '', 'string')
StrOption('a', '')
with pytest.raises(ValueError):
with raises(ValueError):
StrOption('a', '', 1)
u = StrOption('a', '')
SymLinkOption('a', u)
with pytest.raises(ValueError):
with raises(ValueError):
SymLinkOption('a', 'string')
IPOption('a', '')
with pytest.raises(ValueError):
with raises(ValueError):
IPOption('a', '', 1)
with pytest.raises(ValueError):
with raises(ValueError):
IPOption('a', '', 'string')
PortOption('a', '')
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', 'string')
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', '11:12:13', allow_range=True)
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', 11111111111111111111)
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', allow_zero=True, allow_wellknown=False, allow_registred=True, allow_private=False)
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', allow_zero=True, allow_wellknown=True, allow_registred=False, allow_private=True)
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', allow_zero=True, allow_wellknown=False, allow_registred=False, allow_private=True)
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', allow_zero=True, allow_wellknown=False, allow_registred=True, allow_private=True)
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', allow_zero=False, allow_wellknown=False, allow_registred=False, allow_private=False)
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', 'tcp:80')
NetworkOption('a', '')
with pytest.raises(ValueError):
with raises(ValueError):
NetworkOption('a', '', 'string')
NetmaskOption('a', '')
with pytest.raises(ValueError):
with raises(ValueError):
NetmaskOption('a', '', 'string')
BroadcastOption('a', '')
with pytest.raises(ValueError):
with raises(ValueError):
BroadcastOption('a', '', 'string')
DomainnameOption('a', '')
with pytest.raises(ValueError):
with raises(ValueError):
DomainnameOption('a', '', 'string')
with pytest.raises(ValueError):
with raises(ValueError):
DomainnameOption('a', '', type='string')
with pytest.raises(ValueError):
with raises(ValueError):
DomainnameOption('a', '', allow_ip='string')
with pytest.raises(ValueError):
with raises(ValueError):
DomainnameOption('a', '', allow_without_dot='string')
with pytest.raises(ValueError):
with raises(ValueError):
DomainnameOption('a', '', 1)
#
ChoiceOption('a', '', (1,), multi=True, default_multi=1)
with pytest.raises(ValueError):
with raises(ValueError):
ChoiceOption('a', '', (1,), default_multi=1)
with pytest.raises(ValueError):
with raises(ValueError):
ChoiceOption('a', '', (1,), multi=True, default=[1,], default_multi=2)
with pytest.raises(ValueError):
with raises(ValueError):
FloatOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError):
with raises(ValueError):
StrOption('a', '', multi=True, default_multi=1)
with pytest.raises(ValueError):
with raises(ValueError):
IPOption('a', '', multi=True, default_multi=1)
with pytest.raises(ValueError):
with raises(ValueError):
IPOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', multi=True, default_multi='11:12:13', allow_range=True)
with pytest.raises(ValueError):
with raises(ValueError):
PortOption('a', '', multi=True, default_multi=11111111111111111111)
with pytest.raises(ValueError):
with raises(ValueError):
NetworkOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError):
with raises(ValueError):
NetmaskOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError):
with raises(ValueError):
BroadcastOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError):
with raises(ValueError):
DomainnameOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError):
with raises(ValueError):
DomainnameOption('a', '', multi=True, default_multi=1)
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_help():
def test_help():
stro = StrOption('s', '', multi=True)
od1 = OptionDescription('o', '', [stro])
od2 = OptionDescription('o', '', [od1])
async with await Config(od2) as cfg:
cfg = Config(od2)
cfg.help(_display=False)
cfg.config.help(_display=False)
cfg.option.help(_display=False)
cfg.option('o').help(_display=False)
cfg.option('o.s').help(_display=False)
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_config_reset():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.owner.set('test')
assert await cfg.owner.get() == 'test'
assert not await cfg.option('gc.gc2.bool').value.get()
assert not await cfg.option('boolop').property.get()
assert not await cfg.option('boolop').permissive.get()
assert not await cfg.option('wantref').information.get('info', None)
def test_config_reset():
od1 = make_description()
cfg = Config(od1)
cfg.owner.set('test')
assert cfg.owner.get() == 'test'
assert not cfg.option('gc.gc2.bool').value.get()
assert not cfg.option('boolop').property.get()
assert not cfg.option('boolop').permissive.get()
assert not cfg.option('wantref').information.get('info', None)
#
await cfg.option('gc.gc2.bool').value.set(True)
await cfg.option('boolop').property.add('test')
await cfg.option('float').permissive.set(frozenset(['test']))
await cfg.option('wantref').information.set('info', 'info')
assert await cfg.option('gc.gc2.bool').value.get()
assert await cfg.option('boolop').property.get()
assert await cfg.option('float').permissive.get()
assert await cfg.option('wantref').information.get('info', None)
cfg.option('gc.gc2.bool').value.set(True)
cfg.option('boolop').property.add('test')
cfg.option('float').permissive.set(frozenset(['test']))
cfg.option('wantref').information.set('info', 'info')
assert cfg.option('gc.gc2.bool').value.get()
assert cfg.option('boolop').property.get()
assert cfg.option('float').permissive.get()
assert cfg.option('wantref').information.get('info', None)
#
assert await cfg.owner.get() == 'test'
await cfg.config.reset()
assert await cfg.owner.get() == 'test'
assert not await cfg.option('gc.gc2.bool').value.get()
assert not await cfg.option('boolop').property.get()
assert not await cfg.option('float').permissive.get()
assert not await cfg.option('wantref').information.get('info', None)
assert not await list_sessions()
assert cfg.owner.get() == 'test'
cfg.config.reset()
assert cfg.owner.get() == 'test'
assert not cfg.option('gc.gc2.bool').value.get()
assert not cfg.option('boolop').property.get()
assert not cfg.option('float').permissive.get()
assert not cfg.option('wantref').information.get('info', None)
# assert not list_sessions()

294
tests/test_config_domain.py
View file

@ -8,83 +8,103 @@ import pytest
from tiramisu import Config, DomainnameOption, EmailOption, URLOption, OptionDescription
from tiramisu.error import ValueWarning
from tiramisu.i18n import _
from tiramisu.storage import list_sessions
from .config import event_loop
@pytest.mark.asyncio
async def test_domainname(config_type):
def test_domainname(config_type):
d = DomainnameOption('d', '')
f = DomainnameOption('f', '', allow_without_dot=True)
g = DomainnameOption('g', '', allow_ip=True)
h = DomainnameOption('h', '', allow_cidr_network=True)
od = OptionDescription('a', '', [d, f, g, h])
async with await Config(od) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
i = DomainnameOption('i', '', allow_ip=True, allow_cidr_network=True)
j = DomainnameOption('j', '', allow_startswith_dot=True)
od1 = OptionDescription('a', '', [d, f, g, h, i, j])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
#
await cfg.option('d').value.set('toto.com')
cfg.option('d').value.set('toto.com')
with pytest.raises(ValueError):
await cfg.option('d').value.set('toto')
await cfg.option('d').value.set('toto3.com')
cfg.option('d').value.set('.toto.com')
with pytest.raises(ValueError):
await cfg.option('d').value.set('toto_super.com')
await cfg.option('d').value.set('toto-.com')
cfg.option('d').value.set('toto')
cfg.option('d').value.set('toto3.com')
with pytest.raises(ValueError):
await cfg.option('d').value.set('toto..com')
cfg.option('d').value.set('toto_super.com')
cfg.option('d').value.set('toto-.com')
with pytest.raises(ValueError):
cfg.option('d').value.set('toto..com')
#
await cfg.option('f').value.set('toto.com')
await cfg.option('f').value.set('toto')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea')
cfg.option('f').value.set('toto.com')
cfg.option('f').value.set('toto')
cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea')
with pytest.raises(ValueError):
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamean')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nd')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie')
cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamean')
cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nd')
cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie')
with pytest.raises(ValueError):
await cfg.option('d').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowien')
await cfg.option('f').value.set('d')
await cfg.option('f').value.set('d.t')
cfg.option('d').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowien')
cfg.option('f').value.set('d')
cfg.option('f').value.set('d.t')
#
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('f').value.set('192.168.1.1')
cfg.option('f').value.set('192.168.1.1')
with pytest.raises(ValueError):
await cfg.option('f').value.set('192.168.1.0/24')
cfg.option('f').value.set('192.168.1.0/24')
#
await cfg.option('g').value.set('toto.com')
await cfg.option('g').value.set('192.168.1.0')
await cfg.option('g').value.set('192.168.1.29')
cfg.option('g').value.set('toto.com')
cfg.option('g').value.set('192.168.1.0')
cfg.option('g').value.set('192.168.1.29')
with pytest.raises(ValueError):
await cfg.option('g').value.set('192.168.1.0/24')
cfg.option('g').value.set('192.168.1.0/24')
with pytest.raises(ValueError):
cfg.option('g').value.set('240.94.1.1')
#
await cfg.option('h').value.set('toto.com')
cfg.option('h').value.set('toto.com')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('h').value.set('192.168.1.0')
cfg.option('h').value.set('192.168.1.0')
with pytest.raises(ValueError):
await cfg.option('h').value.set('192.168.1.29')
cfg.option('h').value.set('192.168.1.29')
# it's a network address
await cfg.option('h').value.set('192.168.1.0/24')
cfg.option('h').value.set('192.168.1.0/24')
# but not here
with pytest.raises(ValueError):
await cfg.option('h').value.set('192.168.1.1/24')
assert not await list_sessions()
cfg.option('h').value.set('192.168.1.1/24')
#
cfg.option('i').value.set('toto.com')
cfg.option('i').value.set('192.168.1.0')
cfg.option('i').value.set('192.168.1.1')
cfg.option('i').value.set('192.168.1.0/24')
with pytest.raises(ValueError):
cfg.option('i').value.set('192.168.1.1/24')
with pytest.raises(ValueError):
cfg.option('i').value.set('240.94.1.1')
#
cfg.option('j').value.set('toto.com')
cfg.option('j').value.set('.toto.com')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_domainname_upper(config_type):
def test_domainname_invalid(config_type):
with pytest.raises(ValueError):
DomainnameOption('a', '', allow_cidr_network='str')
with pytest.raises(ValueError):
DomainnameOption('a', '', allow_startswith_dot='str')
def test_domainname_upper(config_type):
d = DomainnameOption('d', '')
od = OptionDescription('a', '', [d])
async with await Config(od) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
await cfg.option('d').value.set('toto.com')
od1 = OptionDescription('a', '', [d])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
cfg.option('d').value.set('toto.com')
msg = _('some characters are uppercase')
has_error = False
try:
await cfg.option('d').value.set('TOTO.COM')
cfg.option('d').value.set('TOTO.COM')
except ValueError as err:
if config_type != 'tiramisu-api':
# FIXME
@ -93,171 +113,165 @@ async def test_domainname_upper(config_type):
assert has_error is True
has_error = False
try:
await cfg.option('d').value.set('toTo.com')
cfg.option('d').value.set('toTo.com')
except ValueError as err:
if config_type != 'tiramisu-api':
# FIXME
assert msg in str(err)
has_error = True
assert has_error is True
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_domainname_warning(config_type):
def test_domainname_warning(config_type):
d = DomainnameOption('d', '', warnings_only=True)
f = DomainnameOption('f', '', allow_without_dot=True, warnings_only=True)
g = DomainnameOption('g', '', allow_ip=True, warnings_only=True)
od = OptionDescription('a', '', [d, f, g])
od1 = OptionDescription('a', '', [d, f, g])
warnings.simplefilter("always", ValueWarning)
async with await Config(od) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
await cfg.option('d').value.set('toto.com')
await cfg.option('d').value.set('toto.com.')
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
cfg.option('d').value.set('toto.com')
cfg.option('d').value.set('toto.com.')
with pytest.raises(ValueError):
await cfg.option('d').value.set('toto')
await cfg.option('d').value.set('toto3.com')
cfg.option('d').value.set('toto')
cfg.option('d').value.set('toto3.com')
if config_type != 'tiramisu-api':
# FIXME
with warnings.catch_warnings(record=True) as w:
await cfg.option('d').value.set('toto_super.com')
cfg.option('d').value.set('toto_super.com')
assert len(w) == 1
with warnings.catch_warnings(record=True) as w:
await cfg.option('d').value.set('toto-.com')
cfg.option('d').value.set('toto-.com')
assert len(w) == 0
with pytest.raises(ValueError):
await cfg.option('d').value.set('toto..com')
cfg.option('d').value.set('toto..com')
#
await cfg.option('f').value.set('toto.com')
await cfg.option('f').value.set('toto')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea')
cfg.option('f').value.set('toto.com')
cfg.option('f').value.set('toto')
cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea')
with pytest.raises(ValueError):
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamean')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nd')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie')
cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamean')
cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nd')
cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainname.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnamet.olongthathavemorethanmaximumsizeforatruedomainnameanditsnotea.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie.xxxx')
await cfg.option('f').value.set('d')
await cfg.option('f').value.set('d.t')
cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainname.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnamet.olongthathavemorethanmaximumsizeforatruedomainnameanditsnotea.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie.xxxx')
cfg.option('f').value.set('d')
cfg.option('f').value.set('d.t')
#
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('f').value.set('192.168.1.1')
await cfg.option('g').value.set('toto.com')
await cfg.option('g').value.set('192.168.1.0')
await cfg.option('g').value.set('192.168.1.29')
assert not await list_sessions()
cfg.option('f').value.set('192.168.1.1')
cfg.option('g').value.set('toto.com')
cfg.option('g').value.set('192.168.1.0')
cfg.option('g').value.set('192.168.1.29')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_special_domain_name(config_type):
def test_special_domain_name(config_type):
"""domain name option that starts with a number or not
"""
d = DomainnameOption('d', '')
e = DomainnameOption('e', '', type='netbios')
od = OptionDescription('a', '', [d, e])
async with await Config(od) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
await cfg.option('d').value.set('1toto.com')
await cfg.option('d').value.set('123toto.com')
await cfg.option('e').value.set('toto')
await cfg.option('e').value.set('1toto')
assert not await list_sessions()
od1 = OptionDescription('a', '', [d, e])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
cfg.option('d').value.set('1toto.com')
cfg.option('d').value.set('123toto.com')
cfg.option('e').value.set('toto')
cfg.option('e').value.set('1toto')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_domainname_netbios(config_type):
def test_domainname_netbios(config_type):
d = DomainnameOption('d', '', type='netbios')
e = DomainnameOption('e', '', "toto", type='netbios')
od = OptionDescription('a', '', [d, e])
async with await Config(od) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
od1 = OptionDescription('a', '', [d, e])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
with pytest.raises(ValueError):
await cfg.option('d').value.set('toto.com')
await cfg.option('d').value.set('toto')
cfg.option('d').value.set('toto.com')
cfg.option('d').value.set('toto')
with pytest.raises(ValueError):
await cfg.option('d').value.set('domainnametoolong')
assert not await list_sessions()
cfg.option('d').value.set('domainnametoolong')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_domainname_hostname(config_type):
def test_domainname_hostname(config_type):
d = DomainnameOption('d', '', type='hostname')
e = DomainnameOption('e', '', "toto", type='hostname')
od = OptionDescription('a', '', [d, e])
async with await Config(od) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
od1 = OptionDescription('a', '', [d, e])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
with pytest.raises(ValueError):
await cfg.option('d').value.set('toto.com')
await cfg.option('d').value.set('toto')
await cfg.option('d').value.set('domainnametoolong')
assert not await list_sessions()
cfg.option('d').value.set('toto.com')
cfg.option('d').value.set('toto')
cfg.option('d').value.set('domainnametoolong')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_email(config_type):
def test_email(config_type):
e = EmailOption('e', '')
od = OptionDescription('a', '', [e])
async with await Config(od) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
await cfg.option('e').value.set('foo-bar.baz@example.com')
await cfg.option('e').value.set('root@foo.com')
await cfg.option('e').value.set('root@domain')
od1 = OptionDescription('a', '', [e])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
cfg.option('e').value.set('foo-bar.baz@example.com')
cfg.option('e').value.set('root@foo.com')
cfg.option('e').value.set('root@domain')
with pytest.raises(ValueError):
await cfg.option('e').value.set(1)
cfg.option('e').value.set(1)
with pytest.raises(ValueError):
await cfg.option('e').value.set('root')
cfg.option('e').value.set('root')
with pytest.raises(ValueError):
await cfg.option('e').value.set('root[]@domain')
assert not await list_sessions()
cfg.option('e').value.set('root[]@domain')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_url(config_type):
def test_url(config_type):
u = URLOption('u', '')
od = OptionDescription('a', '', [u])
async with await Config(od) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
await cfg.option('u').value.set('http://foo.com')
await cfg.option('u').value.set('https://foo.com')
await cfg.option('u').value.set('https://foo.com/')
od1 = OptionDescription('a', '', [u])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
cfg.option('u').value.set('http://foo.com')
cfg.option('u').value.set('https://foo.com')
cfg.option('u').value.set('https://foo.com/')
with pytest.raises(ValueError):
await cfg.option('u').value.set(1)
cfg.option('u').value.set(1)
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('u').value.set('ftp://foo.com')
cfg.option('u').value.set('ftp://foo.com')
with pytest.raises(ValueError):
await cfg.option('u').value.set('foo.com')
cfg.option('u').value.set('foo.com')
with pytest.raises(ValueError):
await cfg.option('u').value.set(':/foo.com')
cfg.option('u').value.set(':/foo.com')
with pytest.raises(ValueError):
await cfg.option('u').value.set('foo.com/http://')
await cfg.option('u').value.set('https://foo.com/index.html')
await cfg.option('u').value.set('https://foo.com/index.html?var=value&var2=val2')
cfg.option('u').value.set('foo.com/http://')
cfg.option('u').value.set('https://foo.com/index.html')
cfg.option('u').value.set('https://foo.com/index.html?var=value&var2=val2')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('u').value.set('https://foo.com/index\\n.html')
await cfg.option('u').value.set('https://foo.com:8443')
await cfg.option('u').value.set('https://foo.com:8443/')
await cfg.option('u').value.set('https://foo.com:8443/index.html')
cfg.option('u').value.set('https://foo.com/index\\n.html')
cfg.option('u').value.set('https://foo.com:8443')
cfg.option('u').value.set('https://foo.com:8443/')
cfg.option('u').value.set('https://foo.com:8443/index.html')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('u').value.set('https://foo.com:84438989')
await cfg.option('u').value.set('https://foo.com:8443/INDEX')
cfg.option('u').value.set('https://foo.com:84438989')
cfg.option('u').value.set('https://foo.com:8443/INDEX')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('u').value.set('https://FOO.COM:8443')
assert not await list_sessions()
cfg.option('u').value.set('https://FOO.COM:8443')
# assert not list_sessions()

463
tests/test_config_ip.py
View file

@ -1,416 +1,413 @@
from .autopath import do_autopath
do_autopath()
from .config import config_type, get_config, value_list, global_owner, event_loop
from .config import config_type, get_config, value_list, global_owner
import warnings
import pytest
from tiramisu import Config, IPOption, NetworkOption, NetmaskOption, \
PortOption, BroadcastOption, OptionDescription
from tiramisu.error import ValueWarning
from tiramisu.storage import list_sessions
@pytest.mark.asyncio
async def test_ip(config_type):
def test_ip(config_type):
a = IPOption('a', '')
b = IPOption('b', '', private_only=True)
d = IPOption('d', '', warnings_only=True, private_only=True)
warnings.simplefilter("always", ValueWarning)
od = OptionDescription('od', '', [a, b, d])
async with await Config(od) as cfg:
cfg = await get_config(cfg, config_type)
await cfg.option('a').value.set('192.168.1.1')
await cfg.option('a').value.set('192.168.1.0')
await cfg.option('a').value.set('88.88.88.88')
await cfg.option('a').value.set('0.0.0.0')
od1 = OptionDescription('od', '', [a, b, d])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
cfg.option('a').value.set('192.168.1.1')
cfg.option('a').value.set('192.168.1.0')
cfg.option('a').value.set('88.88.88.88')
cfg.option('a').value.set('0.0.0.0')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('a').value.set('255.255.255.0')
await cfg.option('b').value.set('192.168.1.1')
await cfg.option('b').value.set('192.168.1.0')
cfg.option('a').value.set('255.255.255.0')
cfg.option('b').value.set('192.168.1.1')
cfg.option('b').value.set('192.168.1.0')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('b').value.set('88.88.88.88')
await cfg.option('b').value.set('0.0.0.0')
cfg.option('b').value.set('88.88.88.88')
cfg.option('b').value.set('0.0.0.0')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('b').value.set('255.255.255.0')
cfg.option('b').value.set('255.255.255.0')
with pytest.raises(ValueError):
await cfg.option('a').value.set('333.0.1.20')
cfg.option('a').value.set('333.0.1.20')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
IPOption('a', 'ip', default='192.000.023.01')
with warnings.catch_warnings(record=True) as w:
await cfg.option('d').value.set('88.88.88.88')
cfg.option('d').value.set('88.88.88.88')
assert len(w) == 1
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_ip_cidr():
def test_ip_cidr():
b = IPOption('b', '', private_only=True, cidr=True)
c = IPOption('c', '', private_only=True)
warnings.simplefilter("always", ValueWarning)
od = OptionDescription('od', '', [b, c])
async with await Config(od) as cfg:
od1 = OptionDescription('od', '', [b, c])
cfg = Config(od1)
with pytest.raises(ValueError):
await cfg.option('b').value.set('192.168.1.1')
await cfg.option('b').value.set('192.168.1.1/24')
cfg.option('b').value.set('192.168.1.1')
cfg.option('b').value.set('192.168.1.1/24')
with pytest.raises(ValueError):
await cfg.option('b').value.set('192.168.1.1/32')
cfg.option('b').value.set('192.168.1.0/24')
with pytest.raises(ValueError):
cfg.option('b').value.set('192.168.1.255/24')
with pytest.raises(ValueError):
cfg.option('b').value.set('192.168.1.1/32')
with pytest.raises(ValueError):
cfg.option('b').value.set('192.168.1.1/33')
#
await cfg.option('c').value.set('192.168.1.1')
cfg.option('c').value.set('192.168.1.1')
with pytest.raises(ValueError):
await cfg.option('c').value.set('192.168.1.1/24')
cfg.option('c').value.set('192.168.1.1/24')
with pytest.raises(ValueError):
await cfg.option('c').value.set('192.168.1.1/32')
assert not await list_sessions()
cfg.option('c').value.set('192.168.1.1/32')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_ip_default():
def test_ip_default():
a = IPOption('a', '', '88.88.88.88')
od = OptionDescription('od', '', [a])
async with await Config(od) as cfg:
await cfg.option('a').value.get() == '88.88.88.88'
assert not await list_sessions()
od1 = OptionDescription('od', '', [a])
cfg = Config(od1)
cfg.option('a').value.get() == '88.88.88.88'
# assert not list_sessions()
@pytest.mark.asyncio
async def test_ip_reserved(config_type):
def test_ip_reserved(config_type):
a = IPOption('a', '')
b = IPOption('b', '', allow_reserved=True)
c = IPOption('c', '', warnings_only=True)
od = OptionDescription('od', '', [a, b, c])
od1 = OptionDescription('od', '', [a, b, c])
warnings.simplefilter("always", ValueWarning)
async with await Config(od) as cfg:
cfg = await get_config(cfg, config_type)
cfg = Config(od1)
cfg = get_config(cfg, config_type)
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('a').value.set('240.94.1.1')
await cfg.option('b').value.set('240.94.1.1')
cfg.option('a').value.set('240.94.1.1')
cfg.option('b').value.set('240.94.1.1')
if config_type != 'tiramisu-api':
# FIXME
with warnings.catch_warnings(record=True) as w:
await cfg.option('c').value.set('240.94.1.1')
cfg.option('c').value.set('240.94.1.1')
assert len(w) == 1
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_network(config_type):
def test_network(config_type):
a = NetworkOption('a', '')
b = NetworkOption('b', '', warnings_only=True)
od = OptionDescription('od', '', [a, b])
od1 = OptionDescription('od', '', [a, b])
warnings.simplefilter("always", ValueWarning)
async with await Config(od) as cfg:
cfg = await get_config(cfg, config_type)
await cfg.option('a').value.set('192.168.1.1')
await cfg.option('a').value.set('192.168.1.0')
await cfg.option('a').value.set('88.88.88.88')
await cfg.option('a').value.set('0.0.0.0')
cfg = Config(od1)
cfg = get_config(cfg, config_type)
cfg.option('a').value.set('192.168.1.1')
cfg.option('a').value.set('192.168.1.0')
cfg.option('a').value.set('88.88.88.88')
cfg.option('a').value.set('0.0.0.0')
with pytest.raises(ValueError):
await cfg.option('a').value.set(1)
cfg.option('a').value.set(1)
with pytest.raises(ValueError):
await cfg.option('a').value.set('1.1.1.1.1')
cfg.option('a').value.set('1.1.1.1.1')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('a').value.set('255.255.255.0')
cfg.option('a').value.set('255.255.255.0')
with pytest.raises(ValueError):
await cfg.option('a').value.set('192.168.001.0')
cfg.option('a').value.set('192.168.001.0')
with pytest.raises(ValueError):
await cfg.option('a').value.set('333.168.1.1')
cfg.option('a').value.set('333.168.1.1')
if config_type != 'tiramisu-api':
# FIXME
with warnings.catch_warnings(record=True) as w:
await cfg.option('b').value.set('255.255.255.0')
cfg.option('b').value.set('255.255.255.0')
assert len(w) == 1
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_network_cidr(config_type):
def test_network_cidr(config_type):
a = NetworkOption('a', '', cidr=True)
od = OptionDescription('od', '', [a])
async with await Config(od) as cfg:
# FIXME cfg = await get_config(cfg, config_type)
await cfg.option('a').value.set('192.168.1.1/32')
await cfg.option('a').value.set('192.168.1.0/24')
await cfg.option('a').value.set('88.88.88.88/32')
await cfg.option('a').value.set('0.0.0.0/0')
od1 = OptionDescription('od', '', [a])
cfg = Config(od1)
# FIXME cfg = get_config(cfg, config_type)
cfg.option('a').value.set('192.168.1.1/32')
cfg.option('a').value.set('192.168.1.0/24')
cfg.option('a').value.set('88.88.88.88/32')
cfg.option('a').value.set('0.0.0.0/0')
with pytest.raises(ValueError):
await cfg.option('a').value.set('192.168.1.1')
cfg.option('a').value.set('192.168.1.1')
with pytest.raises(ValueError):
await cfg.option('a').value.set('192.168.1.1/24')
cfg.option('a').value.set('192.168.1.1/24')
with pytest.raises(ValueError):
await cfg.option('a').value.set('2001:db00::0/24')
assert not await list_sessions()
cfg.option('a').value.set('2001:db00::0/24')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_network_invalid():
def test_network_invalid():
with pytest.raises(ValueError):
NetworkOption('a', '', default='toto')
@pytest.mark.asyncio
async def test_netmask(config_type):
def test_netmask(config_type):
a = NetmaskOption('a', '')
od = OptionDescription('od', '', [a])
async with await Config(od) as cfg:
cfg = await get_config(cfg, config_type)
od1 = OptionDescription('od', '', [a])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
with pytest.raises(ValueError):
await cfg.option('a').value.set('192.168.1.1.1')
cfg.option('a').value.set('192.168.1.1.1')
if config_type != 'tiramisu-api':
# FIXME
with pytest.raises(ValueError):
await cfg.option('a').value.set('192.168.1.1')
cfg.option('a').value.set('192.168.1.1')
with pytest.raises(ValueError):
await cfg.option('a').value.set('192.168.1.0')
cfg.option('a').value.set('192.168.1.0')
with pytest.raises(ValueError):
await cfg.option('a').value.set('88.88.88.88')
cfg.option('a').value.set('88.88.88.88')
with pytest.raises(ValueError):
await cfg.option('a').value.set('255.255.255.000')
cfg.option('a').value.set('255.255.255.000')
with pytest.raises(ValueError):
await cfg.option('a').value.set(2)
await cfg.option('a').value.set('0.0.0.0')
await cfg.option('a').value.set('255.255.255.0')
assert not await list_sessions()
cfg.option('a').value.set(2)
cfg.option('a').value.set('0.0.0.0')
cfg.option('a').value.set('255.255.255.0')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_broadcast(config_type):
def test_broadcast(config_type):
a = BroadcastOption('a', '')
od = OptionDescription('od', '', [a])
async with await Config(od) as cfg:
# FIXME cfg = await get_config(cfg, config_type)
od1 = OptionDescription('od', '', [a])
cfg = Config(od1)
# FIXME cfg = get_config(cfg, config_type)
with pytest.raises(ValueError):
await cfg.option('a').value.set('192.168.1.255.1')
cfg.option('a').value.set('192.168.1.255.1')
with pytest.raises(ValueError):
await cfg.option('a').value.set('192.168.001.255')
cfg.option('a').value.set('192.168.001.255')
with pytest.raises(ValueError):
await cfg.option('a').value.set('192.168.0.300')
cfg.option('a').value.set('192.168.0.300')
with pytest.raises(ValueError):
await cfg.option('a').value.set(1)
cfg.option('a').value.set(1)
with pytest.raises(ValueError):
await cfg.option('a').value.set(2)
cfg.option('a').value.set(2)
with pytest.raises(ValueError):
await cfg.option('a').value.set('2001:db8::1')
await cfg.option('a').value.set('0.0.0.0')
await cfg.option('a').value.set('255.255.255.0')
assert not await list_sessions()
cfg.option('a').value.set('2001:db8::1')
cfg.option('a').value.set('0.0.0.0')
cfg.option('a').value.set('255.255.255.0')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_port(config_type):
def test_port(config_type):
a = PortOption('a', '')
b = PortOption('b', '', allow_zero=True)
c = PortOption('c', '', allow_zero=True, allow_registred=False)
d = PortOption('d', '', allow_zero=True, allow_wellknown=False, allow_registred=False)
e = PortOption('e', '', allow_zero=True, allow_private=True)
f = PortOption('f', '', allow_private=True)
od = OptionDescription('od', '', [a, b, c, d, e, f])
async with await Config(od) as cfg:
# FIXME cfg = await get_config(cfg, config_type)
g = PortOption('g', '', warnings_only=True)
od1 = OptionDescription('od', '', [a, b, c, d, e, f, g])
cfg = Config(od1)
# FIXME cfg = get_config(cfg, config_type)
with pytest.raises(ValueError):
await cfg.option('a').value.set('0')
await cfg.option('a').value.set('1')
await cfg.option('a').value.set('1023')
await cfg.option('a').value.set('1024')
await cfg.option('a').value.set('49151')
cfg.option('a').value.set('0')
with warnings.catch_warnings(record=True) as w:
cfg.option('g').value.set('0')
assert len(w) == 1
cfg.option('a').value.set('1')
cfg.option('a').value.set('1023')
cfg.option('a').value.set('1024')
cfg.option('a').value.set('49151')
with pytest.raises(ValueError):
await cfg.option('a').value.set('49152')
cfg.option('a').value.set('49152')
with pytest.raises(ValueError):
await cfg.option('a').value.set('65535')
cfg.option('a').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('a').value.set('65536')
cfg.option('a').value.set('65536')
await cfg.option('b').value.set('0')
await cfg.option('b').value.set('1')
await cfg.option('b').value.set('1023')
await cfg.option('b').value.set('1024')
await cfg.option('b').value.set('49151')
cfg.option('b').value.set('0')
cfg.option('b').value.set('1')
cfg.option('b').value.set('1023')
cfg.option('b').value.set('1024')
cfg.option('b').value.set('49151')
with pytest.raises(ValueError):
await cfg.option('b').value.set('49152')
cfg.option('b').value.set('49152')
with pytest.raises(ValueError):
await cfg.option('b').value.set('65535')
cfg.option('b').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('b').value.set('65536')
cfg.option('b').value.set('65536')
await cfg.option('c').value.set('0')
await cfg.option('c').value.set('1')
await cfg.option('c').value.set('1023')
cfg.option('c').value.set('0')
cfg.option('c').value.set('1')
cfg.option('c').value.set('1023')
with pytest.raises(ValueError):
await cfg.option('c').value.set('1024')
cfg.option('c').value.set('1024')
with pytest.raises(ValueError):
await cfg.option('c').value.set('49151')
cfg.option('c').value.set('49151')
with pytest.raises(ValueError):
await cfg.option('c').value.set('49152')
cfg.option('c').value.set('49152')
with pytest.raises(ValueError):
await cfg.option('c').value.set('65535')
cfg.option('c').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('c').value.set('65536')
cfg.option('c').value.set('65536')
await cfg.option('d').value.set('0')
cfg.option('d').value.set('0')
with pytest.raises(ValueError):
await cfg.option('d').value.set('1')
cfg.option('d').value.set('1')
with pytest.raises(ValueError):
await cfg.option('d').value.set('1023')
cfg.option('d').value.set('1023')
with pytest.raises(ValueError):
await cfg.option('d').value.set('1024')
cfg.option('d').value.set('1024')
with pytest.raises(ValueError):
await cfg.option('d').value.set('49151')
cfg.option('d').value.set('49151')
with pytest.raises(ValueError):
await cfg.option('d').value.set('49152')
cfg.option('d').value.set('49152')
with pytest.raises(ValueError):
await cfg.option('d').value.set('65535')
cfg.option('d').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('d').value.set('65536')
cfg.option('d').value.set('65536')
await cfg.option('e').value.set('0')
await cfg.option('e').value.set('1')
await cfg.option('e').value.set('1023')
await cfg.option('e').value.set('1024')
await cfg.option('e').value.set('49151')
await cfg.option('e').value.set('49152')
await cfg.option('e').value.set('65535')
cfg.option('e').value.set('0')
cfg.option('e').value.set('1')
cfg.option('e').value.set('1023')
cfg.option('e').value.set('1024')
cfg.option('e').value.set('49151')
cfg.option('e').value.set('49152')
cfg.option('e').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('f').value.set('0')
await cfg.option('f').value.set('1')
await cfg.option('f').value.set('1023')
await cfg.option('f').value.set('1024')
await cfg.option('f').value.set('49151')
await cfg.option('f').value.set('49152')
await cfg.option('f').value.set('65535')
cfg.option('f').value.set('0')
cfg.option('f').value.set('1')
cfg.option('f').value.set('1023')
cfg.option('f').value.set('1024')
cfg.option('f').value.set('49151')
cfg.option('f').value.set('49152')
cfg.option('f').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('f').value.set('65536')
assert not await list_sessions()
cfg.option('f').value.set('65536')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_port_protocol(config_type):
def test_port_protocol(config_type):
a = PortOption('a', '', allow_protocol=True)
od = OptionDescription('od', '', [a])
async with await Config(od) as cfg:
await cfg.option('a').value.set('80')
await cfg.option('a').value.set('tcp:80')
assert not await list_sessions()
od1 = OptionDescription('od', '', [a])
cfg = Config(od1)
cfg.option('a').value.set('80')
cfg.option('a').value.set('tcp:80')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_port_range(config_type):
def test_port_range(config_type):
a = PortOption('a', '', allow_range=True)
b = PortOption('b', '', allow_range=True, allow_zero=True)
c = PortOption('c', '', allow_range=True, allow_zero=True, allow_registred=False)
d = PortOption('d', '', allow_range=True, allow_zero=True, allow_wellknown=False, allow_registred=False)
e = PortOption('e', '', allow_range=True, allow_zero=True, allow_private=True)
f = PortOption('f', '', allow_range=True, allow_private=True)
od = OptionDescription('od', '', [a, b, c, d, e, f])
async with await Config(od) as cfg:
# FIXME cfg = await get_config(cfg, config_type)
od1 = OptionDescription('od', '', [a, b, c, d, e, f])
cfg = Config(od1)
# FIXME cfg = get_config(cfg, config_type)
with pytest.raises(ValueError):
await cfg.option('a').value.set('0')
await cfg.option('a').value.set('1')
await cfg.option('a').value.set('1023')
await cfg.option('a').value.set('1024')
await cfg.option('a').value.set('49151')
cfg.option('a').value.set('0')
cfg.option('a').value.set('1')
cfg.option('a').value.set('1023')
cfg.option('a').value.set('1024')
cfg.option('a').value.set('49151')
with pytest.raises(ValueError):
await cfg.option('a').value.set('49152')
cfg.option('a').value.set('49152')
with pytest.raises(ValueError):
await cfg.option('a').value.set('65535')
cfg.option('a').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('a').value.set('65536')
await cfg.option('a').value.set('1:49151')
cfg.option('a').value.set('65536')
cfg.option('a').value.set('1:49151')
with pytest.raises(ValueError):
await cfg.option('a').value.set('0:49151')
cfg.option('a').value.set('0:49151')
with pytest.raises(ValueError):
await cfg.option('a').value.set('1:49152')
cfg.option('a').value.set('1:49152')
await cfg.option('b').value.set('0')
await cfg.option('b').value.set('1')
await cfg.option('b').value.set('1023')
await cfg.option('b').value.set('1024')
await cfg.option('b').value.set('49151')
cfg.option('b').value.set('0')
cfg.option('b').value.set('1')
cfg.option('b').value.set('1023')
cfg.option('b').value.set('1024')
cfg.option('b').value.set('49151')
with pytest.raises(ValueError):
await cfg.option('b').value.set('49152')
cfg.option('b').value.set('49152')
with pytest.raises(ValueError):
await cfg.option('b').value.set('65535')
cfg.option('b').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('b').value.set('65536')
await cfg.option('b').value.set('0:49151')
cfg.option('b').value.set('65536')
cfg.option('b').value.set('0:49151')
with pytest.raises(ValueError):
await cfg.option('b').value.set('0:49152')
cfg.option('b').value.set('0:49152')
await cfg.option('c').value.set('0')
await cfg.option('c').value.set('1')
await cfg.option('c').value.set('1023')
cfg.option('c').value.set('0')
cfg.option('c').value.set('1')
cfg.option('c').value.set('1023')
with pytest.raises(ValueError):
await cfg.option('c').value.set('1024')
cfg.option('c').value.set('1024')
with pytest.raises(ValueError):
await cfg.option('c').value.set('49151')
cfg.option('c').value.set('49151')
with pytest.raises(ValueError):
await cfg.option('c').value.set('49152')
cfg.option('c').value.set('49152')
with pytest.raises(ValueError):
await cfg.option('c').value.set('65535')
cfg.option('c').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('c').value.set('65536')
await cfg.option('c').value.set('0:1023')
cfg.option('c').value.set('65536')
cfg.option('c').value.set('0:1023')
with pytest.raises(ValueError):
await cfg.option('c').value.set('0:1024')
cfg.option('c').value.set('0:1024')
await cfg.option('d').value.set('0')
cfg.option('d').value.set('0')
with pytest.raises(ValueError):
await cfg.option('d').value.set('1')
cfg.option('d').value.set('1')
with pytest.raises(ValueError):
await cfg.option('d').value.set('1023')
cfg.option('d').value.set('1023')
with pytest.raises(ValueError):
await cfg.option('d').value.set('1024')
cfg.option('d').value.set('1024')
with pytest.raises(ValueError):
await cfg.option('d').value.set('49151')
cfg.option('d').value.set('49151')
with pytest.raises(ValueError):
await cfg.option('d').value.set('49152')
cfg.option('d').value.set('49152')
with pytest.raises(ValueError):
await cfg.option('d').value.set('65535')
cfg.option('d').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('d').value.set('65536')
cfg.option('d').value.set('65536')
with pytest.raises(ValueError):
await cfg.option('d').value.set('0:0')
cfg.option('d').value.set('0:0')
with pytest.raises(ValueError):
await cfg.option('d').value.set('0:1')
cfg.option('d').value.set('0:1')
await cfg.option('e').value.set('0')
await cfg.option('e').value.set('1')
await cfg.option('e').value.set('1023')
await cfg.option('e').value.set('1024')
await cfg.option('e').value.set('49151')
await cfg.option('e').value.set('49152')
await cfg.option('e').value.set('65535')
await cfg.option('e').value.set('0:65535')
cfg.option('e').value.set('0')
cfg.option('e').value.set('1')
cfg.option('e').value.set('1023')
cfg.option('e').value.set('1024')
cfg.option('e').value.set('49151')
cfg.option('e').value.set('49152')
cfg.option('e').value.set('65535')
cfg.option('e').value.set('0:65535')
with pytest.raises(ValueError):
await cfg.option('e').value.set('0:65536')
cfg.option('e').value.set('0:65536')
with pytest.raises(ValueError):
await cfg.option('f').value.set('0')
await cfg.option('f').value.set('1')
await cfg.option('f').value.set('1023')
await cfg.option('f').value.set('1024')
await cfg.option('f').value.set('49151')
await cfg.option('f').value.set('49152')
await cfg.option('f').value.set('65535')
cfg.option('f').value.set('0')
cfg.option('f').value.set('1')
cfg.option('f').value.set('1023')
cfg.option('f').value.set('1024')
cfg.option('f').value.set('49151')
cfg.option('f').value.set('49152')
cfg.option('f').value.set('65535')
with pytest.raises(ValueError):
await cfg.option('f').value.set('65536')
await cfg.option('f').value.set('1:65535')
await cfg.option('f').value.set('3:4')
cfg.option('f').value.set('65536')
cfg.option('f').value.set('1:65535')
cfg.option('f').value.set('3:4')
with pytest.raises(ValueError):
await cfg.option('f').value.set('0:65535')
cfg.option('f').value.set('0:65535')
with pytest.raises(ValueError):
await cfg.option('f').value.set('4:3')
assert not await list_sessions()
cfg.option('f').value.set('4:3')
# assert not list_sessions()

138
tests/test_dereference.py
View file

@ -7,64 +7,40 @@ import pytest
from tiramisu import BoolOption, IntOption, StrOption, IPOption, NetmaskOption, \
SymLinkOption, OptionDescription, DynOptionDescription, submulti, \
Config, GroupConfig, MetaConfig, Params, ParamOption, Calculation
from tiramisu.storage import list_sessions
from .config import event_loop
IS_DEREFABLE = True
def funcname(*args, **kwargs):
return value
@pytest.mark.asyncio
async def test_deref_storage():
def test_deref_value():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
async with await Config(o) as cfg:
w = weakref.ref(cfg._config_bag.context.cfgimpl_get_values()._p_)
cfg = Config(o)
w = weakref.ref(cfg._config_bag.context.get_values())
del cfg
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_value():
def test_deref_setting():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
async with await Config(o) as cfg:
w = weakref.ref(cfg._config_bag.context.cfgimpl_get_values())
cfg = Config(o)
w = weakref.ref(cfg._config_bag.context.get_settings())
del cfg
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_setting():
def test_deref_config():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
async with await Config(o) as cfg:
w = weakref.ref(cfg._config_bag.context.cfgimpl_get_settings())
del cfg
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_config():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
async with await Config(o) as cfg:
cfg = Config(o)
w = weakref.ref(cfg)
del cfg
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_option():
global IS_DEREFABLE
def test_deref_option():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
w = weakref.ref(b)
@ -72,17 +48,12 @@ async def test_deref_option():
try:
assert w() is not None
except AssertionError:
IS_DEREFABLE = False
return
del(o)
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_optiondescription():
if not IS_DEREFABLE:
return
def test_deref_optiondescription():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
w = weakref.ref(o)
@ -90,46 +61,34 @@ async def test_deref_optiondescription():
assert w() is not None
del(o)
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_option_cache():
if not IS_DEREFABLE:
return
def test_deref_option_cache():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
await o._build_cache()
o._build_cache()
w = weakref.ref(b)
del(b)
assert w() is not None
del(o)
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_optiondescription_cache():
if not IS_DEREFABLE:
return
def test_deref_optiondescription_cache():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
await o._build_cache()
o._build_cache()
w = weakref.ref(o)
del(b)
assert w() is not None
del(o)
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_option_config():
if not IS_DEREFABLE:
return
def test_deref_option_config():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
async with await Config(o) as cfg:
cfg = Config(o)
w = weakref.ref(b)
del(b)
assert w() is not None
@ -137,16 +96,12 @@ async def test_deref_option_config():
assert w() is not None
del cfg
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_optiondescription_config():
if not IS_DEREFABLE:
return
def test_deref_optiondescription_config():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
async with await Config(o) as cfg:
cfg = Config(o)
w = weakref.ref(o)
del(b)
assert w() is not None
@ -154,20 +109,16 @@ async def test_deref_optiondescription_config():
assert w() is not None
del cfg
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_validator():
if not IS_DEREFABLE:
return
def test_deref_validator():
a = StrOption('a', '', default='yes')
b = StrOption('b', '', validators=[Calculation(funcname, Params(ParamOption(a)))], default='val')
od = OptionDescription('root', '', [a, b])
async with await Config(od) as cfg:
o = OptionDescription('root', '', [a, b])
cfg = Config(o)
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(od)
y = weakref.ref(o)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
@ -179,7 +130,7 @@ async def test_deref_validator():
assert x() is not None
assert w() is not None
assert x() is not None
del(od)
del(o)
assert w() is not None
assert x() is not None
assert w() is not None
@ -187,20 +138,16 @@ async def test_deref_validator():
del cfg
assert y() is None
assert z() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_callback():
if not IS_DEREFABLE:
return
def test_deref_callback():
a = StrOption('a', "", 'val')
b = StrOption('b', "", Calculation(funcname, Params((ParamOption(a),))))
od = OptionDescription('root', '', [a, b])
async with await Config(od) as cfg:
o = OptionDescription('root', '', [a, b])
cfg = Config(o)
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(od)
y = weakref.ref(o)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
@ -212,7 +159,7 @@ async def test_deref_callback():
assert x() is not None
assert w() is not None
assert x() is not None
del(od)
del(o)
assert w() is not None
assert x() is not None
assert w() is not None
@ -220,20 +167,16 @@ async def test_deref_callback():
del cfg
assert y() is None
assert z() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_symlink():
if not IS_DEREFABLE:
return
def test_deref_symlink():
a = BoolOption("a", "", default=False)
b = SymLinkOption("b", a)
od = OptionDescription('root', '', [a, b])
async with await Config(od) as cfg:
o = OptionDescription('root', '', [a, b])
cfg = Config(o)
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(od)
y = weakref.ref(o)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
@ -245,7 +188,7 @@ async def test_deref_symlink():
assert x() is not None
assert w() is not None
assert x() is not None
del(od)
del(o)
assert w() is not None
assert x() is not None
assert w() is not None
@ -253,21 +196,17 @@ async def test_deref_symlink():
del cfg
assert y() is None
assert z() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_dyn():
if not IS_DEREFABLE:
return
def test_deref_dyn():
a = StrOption('a', '', ['val1', 'val2'], multi=True)
b = StrOption('b', '')
dod = DynOptionDescription('dod', '', [b], suffixes=Calculation(funcname, Params((ParamOption(a),))))
od = OptionDescription('od', '', [dod, a])
async with await Config(od) as cfg:
o = OptionDescription('od', '', [dod, a])
cfg = Config(o)
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(od)
y = weakref.ref(o)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
@ -279,7 +218,7 @@ async def test_deref_dyn():
assert x() is not None
assert w() is not None
assert x() is not None
del(od)
del(o)
del(dod)
assert w() is not None
assert x() is not None
@ -288,4 +227,3 @@ async def test_deref_dyn():
del cfg
assert y() is None
assert z() is None
assert not await list_sessions()

94
tests/test_duplicate_config.py
View file

@ -6,8 +6,6 @@ import pytest
from tiramisu.setting import groups
from tiramisu import Config, MetaConfig, ChoiceOption, BoolOption, IntOption, \
StrOption, OptionDescription, groups
from tiramisu.storage import list_sessions
from .config import event_loop
def make_description():
@ -43,62 +41,54 @@ def make_description():
return descr
def to_tuple(val):
return tuple([tuple(v) for v in val])
def test_copy():
od1 = make_description()
cfg = Config(od1)
ncfg = cfg.config.copy()
assert cfg.option('creole.general.numero_etab').value.get() == None
cfg.option('creole.general.numero_etab').value.set('oui')
assert cfg.option('creole.general.numero_etab').value.get() == 'oui'
assert ncfg.option('creole.general.numero_etab').value.get() == None
# assert not list_sessions()
@pytest.mark.asyncio
async def test_copy():
od = make_description()
async with await Config(od) as cfg:
async with await cfg.config.copy() as ncfg:
assert await cfg.option('creole.general.numero_etab').value.get() == None
await cfg.option('creole.general.numero_etab').value.set('oui')
assert await cfg.option('creole.general.numero_etab').value.get() == 'oui'
assert await ncfg.option('creole.general.numero_etab').value.get() == None
assert not await list_sessions()
def test_copy_information():
od1 = make_description()
cfg = Config(od1)
cfg.information.set('key', 'value')
ncfg = cfg.config.copy()
assert ncfg.information.get('key') == 'value'
# assert not list_sessions()
@pytest.mark.asyncio
async def test_copy_information():
od = make_description()
async with await Config(od) as cfg:
await cfg.information.set('key', 'value')
async with await cfg.config.copy() as ncfg:
assert await ncfg.information.get('key') == 'value'
assert not await list_sessions()
@pytest.mark.asyncio
async def test_copy_force_store_value():
od = make_description()
async with await Config(od) as conf:
async with await Config(od) as conf2:
assert to_tuple(await conf.value.exportation()) == ((), (), (), ())
assert to_tuple(await conf2.value.exportation()) == ((), (), (), ())
def test_copy_force_store_value():
od1 = make_description()
conf = Config(od1)
conf2 = Config(od1)
assert conf.value.exportation() == {}
assert conf2.value.exportation() == {}
#
await conf.property.read_write()
assert to_tuple(await conf.value.exportation()) == (('creole.general.wantref',), (None,), (False,), ('forced',))
assert to_tuple(await conf2.value.exportation()) == ((), (), (), ())
conf.property.read_write()
assert conf.value.exportation() == {'creole.general.wantref': {None: [False, 'forced']}}
assert conf2.value.exportation() == {}
#
await conf2.property.read_only()
assert to_tuple(await conf.value.exportation()) == (('creole.general.wantref',), (None,), (False,), ('forced',))
assert to_tuple(await conf2.value.exportation()) == (('creole.general.wantref',), (None,), (False,), ('forced',))
conf2.property.read_only()
assert conf.value.exportation() == {'creole.general.wantref': {None: [False, 'forced']}}
assert conf2.value.exportation() == {'creole.general.wantref': {None: [False, 'forced']}}
#
await conf.option('creole.general.wantref').value.set(True)
assert to_tuple(await conf.value.exportation()) == (('creole.general.wantref',), (None,), (True,), ('user',))
assert to_tuple(await conf2.value.exportation()) == (('creole.general.wantref',), (None,), (False,), ('forced',))
assert not await list_sessions()
conf.option('creole.general.wantref').value.set(True)
assert conf.value.exportation() == {'creole.general.wantref': {None: [True, 'user']}}
assert conf2.value.exportation() == {'creole.general.wantref': {None: [False, 'forced']}}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_copy_force_store_value_metaconfig():
descr = make_description()
async with await MetaConfig([], optiondescription=descr) as meta:
async with await meta.config.new(session_id='conf') as conf:
assert await meta.property.get() == await conf.property.get()
assert await meta.permissive.get() == await conf.permissive.get()
await conf.property.read_write()
assert to_tuple(await conf.value.exportation()) == (('creole.general.wantref',), (None,), (False,), ('forced',))
assert to_tuple(await meta.value.exportation()) == ((), (), (), ())
assert not await list_sessions()
def test_copy_force_store_value_metaconfig():
od1 = make_description()
meta = MetaConfig([], optiondescription=od1)
conf = meta.config.new()
assert meta.property.get() == conf.property.get()
assert meta.permissive.get() == conf.permissive.get()
conf.property.read_write()
assert conf.value.exportation() == {'creole.general.wantref': {None: [False, 'forced']}}
assert meta.value.exportation() == {}
# assert not list_sessions()

2174
tests/test_dyn_optiondescription.py
View file

File diff suppressed because it is too large Load diff

184
tests/test_freeze.py
View file

@ -8,22 +8,12 @@ import pytest
from tiramisu.setting import owners, groups
from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
StrOption, OptionDescription, SymLinkOption, Leadership, Config, \
Calculation, Params, ParamOption, ParamValue, calc_value, delete_session
Calculation, Params, ParamOption, ParamValue, calc_value
from tiramisu.error import PropertiesOptionError, ConfigError
from tiramisu.storage import list_sessions
from .config import event_loop
def compare(calculated, expected):
def convert_list(val):
if isinstance(val, list):
val = tuple(val)
return val
# convert to tuple
for idx in range(len(calculated[0])):
right_idx = expected[0].index(calculated[0][idx])
for typ in range(4):
assert convert_list(calculated[typ][idx]) == expected[typ][right_idx]
assert calculated == expected
#____________________________________________________________
@ -76,151 +66,151 @@ def return_val3(context, value):
return value
@pytest.mark.asyncio
async def test_freeze_whole_config():
descr = make_description_freeze()
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.property.add('everything_frozen')
assert await cfg.option('gc.dummy').value.get() is False
def test_freeze_whole_config():
od1 = make_description_freeze()
cfg = Config(od1)
cfg.property.read_write()
cfg.property.add('everything_frozen')
assert cfg.option('gc.dummy').value.get() is False
prop = []
try:
await cfg.option('gc.dummy').value.set(True)
cfg.option('gc.dummy').value.set(True)
except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
assert await cfg.option('gc.dummy').value.get() is False
assert cfg.option('gc.dummy').value.get() is False
#
await cfg.property.pop('everything_frozen')
await cfg.option('gc.dummy').value.set(True)
assert await cfg.option('gc.dummy').value.get() is True
cfg.property.remove('everything_frozen')
cfg.option('gc.dummy').value.set(True)
assert cfg.option('gc.dummy').value.get() is True
#
await cfg.property.add('everything_frozen')
cfg.property.add('everything_frozen')
owners.addowner("everythingfrozen2")
prop = []
try:
await cfg.option('gc.dummy').owner.set('everythingfrozen2')
cfg.option('gc.dummy').owner.set('everythingfrozen2')
except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_freeze_one_option():
def test_freeze_one_option():
"freeze an option "
descr = make_description_freeze()
async with await Config(descr) as cfg:
await cfg.property.read_write()
od1 = make_description_freeze()
cfg = Config(od1)
cfg.property.read_write()
#freeze only one option
await cfg.option('gc.dummy').property.add('frozen')
assert await cfg.option('gc.dummy').value.get() is False
cfg.option('gc.dummy').property.add('frozen')
assert cfg.option('gc.dummy').value.get() is False
prop = []
try:
await cfg.option('gc.dummy').value.set(True)
cfg.option('gc.dummy').value.set(True)
except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_frozen_value():
def test_frozen_value():
"setattr a frozen value at the config level"
s = StrOption("string", "", default="string")
descr = OptionDescription("options", "", [s])
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.property.add('frozen')
await cfg.option('string').property.add('frozen')
od1 = OptionDescription("options", "", [s])
cfg = Config(od1)
cfg.property.read_write()
cfg.property.add('frozen')
cfg.option('string').property.add('frozen')
prop = []
try:
await cfg.option('string').value.set('egg')
cfg.option('string').value.set('egg')
except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_freeze():
def test_freeze():
"freeze a whole configuration object"
descr = make_description_freeze()
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.property.add('frozen')
await cfg.option('gc.name').property.add('frozen')
od1 = make_description_freeze()
cfg = Config(od1)
cfg.property.read_write()
cfg.property.add('frozen')
cfg.option('gc.name').property.add('frozen')
prop = []
try:
await cfg.option('gc.name').value.set('framework')
cfg.option('gc.name').value.set('framework')
except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_freeze_multi():
descr = make_description_freeze()
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.property.add('frozen')
await cfg.option('boolop').property.add('frozen')
def test_freeze_multi():
od1 = make_description_freeze()
cfg = Config(od1)
cfg.property.read_write()
cfg.property.add('frozen')
cfg.option('boolop').property.add('frozen')
prop = []
try:
await cfg.option('boolop').value.set([True])
cfg.option('boolop').value.set([True])
except PropertiesOptionError as err:
prop = err.proptype
assert 'frozen' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_store_value():
descr = make_description_freeze()
async with await Config(descr) as cfg:
compare(await cfg.value.exportation(), (('wantref', 'wantref2', 'wantref3'), (None, None, None), (False, False, (False,)), ('forced', 'forced', 'forced')))
await cfg.option('wantref').value.set(True)
compare(await cfg.value.exportation(), (('wantref', 'wantref2', 'wantref3'), (None, None, None), (True, False, (False,)), ('user', 'forced', 'forced')))
await cfg.option('wantref').value.reset()
compare(await cfg.value.exportation(), (('wantref', 'wantref2', 'wantref3'), (None, None, None), (False, False, (False,)), ('forced', 'forced', 'forced')))
assert not await list_sessions()
def test_force_store_value():
od1 = make_description_freeze()
cfg = Config(od1)
compare(cfg.value.exportation(), {})
cfg.property.read_write()
compare(cfg.value.exportation(), {'wantref': {None: [False, 'forced']}, 'wantref2': {None: [False, 'forced']}, 'wantref3': {None: [[False], 'forced']}})
cfg.option('bool').value.set(False)
cfg.option('wantref').value.set(True)
cfg.option('bool').value.reset()
compare(cfg.value.exportation(), {'wantref': {None: [True, 'user']}, 'wantref2': {None: [False, 'forced']}, 'wantref3': {None: [[False], 'forced']}})
cfg.option('bool').value.set(False)
cfg.option('wantref').value.reset()
cfg.option('bool').value.reset()
compare(cfg.value.exportation(), {'wantref': {None: [False, 'forced']}, 'wantref2': {None: [False, 'forced']}, 'wantref3': {None: [[False], 'forced']}})
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_store_value_leadership_sub():
def test_force_store_value_leadership_sub():
b = IntOption('int', 'Test int option', multi=True, properties=('force_store_value',))
c = StrOption('str', 'Test string option', multi=True)
descr = Leadership("int", "", [b, c])
odr = OptionDescription('odr', '', [descr])
async with await Config(odr) as cfg:
compare(await cfg.value.exportation(), (('int.int',), (None,), (tuple(),), ('forced',)))
assert not await list_sessions()
od1 = OptionDescription('odr', '', [descr])
cfg = Config(od1)
cfg.property.read_only()
compare(cfg.value.exportation(), {'int.int': {None: [[], 'forced']}})
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_store_value_callback():
def test_force_store_value_callback():
b = IntOption('int', 'Test int option', Calculation(return_val), properties=('force_store_value',))
descr = OptionDescription("int", "", [b])
async with await Config(descr) as cfg:
compare(await cfg.value.exportation(), (('int',), (None,), (1,), ('forced',)))
assert not await list_sessions()
od1 = OptionDescription("int", "", [b])
cfg = Config(od1)
cfg.property.read_only()
compare(cfg.value.exportation(), {'int': {None: [1, 'forced']}})
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_store_value_callback_params():
def test_force_store_value_callback_params():
b = IntOption('int', 'Test int option', Calculation(return_val2, Params(kwargs={'value': ParamValue(2)})), properties=('force_store_value',))
descr = OptionDescription("int", "", [b])
async with await Config(descr) as cfg:
compare(await cfg.value.exportation(), (('int',), (None,), (2,), ('forced',)))
assert not await list_sessions()
od1 = OptionDescription("int", "", [b])
cfg = Config(od1)
cfg.property.read_only()
compare(cfg.value.exportation(), {'int': {None: [2, 'forced']}})
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_store_value_callback_params_with_opt():
def test_force_store_value_callback_params_with_opt():
a = IntOption('val1', "", 2)
b = IntOption('int', 'Test int option', Calculation(return_val2, Params(kwargs={'value': ParamOption(a)})), properties=('force_store_value',))
descr = OptionDescription("int", "", [a, b])
async with await Config(descr) as cfg:
compare(await cfg.value.exportation(), (('int',), (None,), (2,), ('forced',)))
assert not await list_sessions()
od1 = OptionDescription("int", "", [a, b])
cfg = Config(od1)
cfg.property.read_only()
compare(cfg.value.exportation(), {'int': {None: [2, 'forced']}})
# assert not list_sessions()

1284
tests/test_leadership.py
View file

File diff suppressed because it is too large Load diff

738
tests/test_mandatory.py
View file

@ -10,8 +10,6 @@ from tiramisu import IntOption, StrOption, OptionDescription, \
ParamOption, ParamValue, calc_value
from tiramisu.error import PropertiesOptionError, ConfigError
from tiramisu.setting import groups
from tiramisu.storage import list_sessions
from .config import event_loop
#def teardown_function(function):
@ -76,533 +74,514 @@ def make_description3():
return descr
@pytest.mark.asyncio
async def test_mandatory_ro():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_only()
def test_mandatory_ro():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_only()
prop = []
try:
await cfg.option('str1').value.get()
cfg.option('str1').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
await cfg.property.read_write()
await cfg.option('str1').value.set('yes')
await cfg.property.read_only()
assert await cfg.option('str1').value.get() == 'yes'
assert not await list_sessions()
cfg.property.read_write()
cfg.option('str1').value.set('yes')
cfg.property.read_only()
assert cfg.option('str1').value.get() == 'yes'
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_ro_dict():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_only()
def test_mandatory_ro_dict():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_only()
prop = []
try:
await cfg.value.dict()
cfg.value.dict()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
await cfg.property.read_write()
await cfg.option('str1').value.set('yes')
await cfg.option('unicode2').value.set('yes')
await cfg.property.read_only()
cfg.property.read_write()
cfg.option('str1').value.set('yes')
cfg.option('unicode2').value.set('yes')
cfg.property.read_only()
try:
await cfg.value.dict()
cfg.value.dict()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
await cfg.property.read_write()
await cfg.option('str3').value.set(['yes'])
await cfg.property.read_only()
assert await cfg.value.dict() == {'str': 'abc', 'str1': 'yes', 'str3': ['yes'], 'unicode2': 'yes'}
assert not await list_sessions()
cfg.property.read_write()
cfg.option('str3').value.set(['yes'])
cfg.property.read_only()
assert cfg.value.dict() == {'str': 'abc', 'str1': 'yes', 'str3': ['yes'], 'unicode2': 'yes'}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_rw():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
def test_mandatory_rw():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
# not mandatory in rw
await cfg.option('str1').value.get()
await cfg.option('str1').value.set('yes')
assert await cfg.option('str1').value.get() == 'yes'
assert not await list_sessions()
cfg.option('str1').value.get()
cfg.option('str1').value.set('yes')
assert cfg.option('str1').value.get() == 'yes'
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_default():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_only()
def test_mandatory_default():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_only()
#not mandatory in rw
await cfg.option('str').value.get()
await cfg.property.read_write()
await cfg.option('str').value.set('yes')
await cfg.property.read_only()
await cfg.option('str').value.get()
await cfg.property.read_write()
await cfg.option('str').value.set(None)
await cfg.property.read_only()
cfg.option('str').value.get()
cfg.property.read_write()
cfg.option('str').value.set('yes')
cfg.property.read_only()
cfg.option('str').value.get()
cfg.property.read_write()
cfg.option('str').value.set(None)
cfg.property.read_only()
prop = []
try:
await cfg.option('str').value.get()
cfg.option('str').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_delete():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_only()
await cfg.option('str').value.get()
def test_mandatory_delete():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_only()
cfg.option('str').value.get()
try:
await cfg.option('str1').value.get()
cfg.option('str1').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
await cfg.property.read_write()
await cfg.option('str1').value.set('yes')
await cfg.property.read_only()
assert await cfg.option('str1').value.get() == 'yes'
await cfg.property.pop('everything_frozen')
cfg.property.read_write()
cfg.option('str1').value.set('yes')
cfg.property.read_only()
assert cfg.option('str1').value.get() == 'yes'
cfg.property.remove('everything_frozen')
prop = []
try:
await cfg.option('str1').value.reset()
cfg.option('str1').value.reset()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
await cfg.option('str').value.reset()
cfg.option('str').value.reset()
assert await cfg.option('str1').value.get() == 'yes'
assert not await list_sessions()
assert cfg.option('str1').value.get() == 'yes'
# assert not list_sessions()
#valeur vide : None, '', u'', ...
@pytest.mark.asyncio
async def test_mandatory_none():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str1').value.set(None)
assert await cfg.option('str1').owner.get() == 'user'
await cfg.property.read_only()
def test_mandatory_none():
od1 = make_description()
cfg = Config(od1)
cfg.option('str1').value.set(None)
assert cfg.option('str1').owner.get() == 'user'
cfg.property.read_only()
prop = []
try:
await cfg.option('str1').value.get()
cfg.option('str1').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_empty():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str1').value.set('')
assert await cfg.option('str1').owner.get() == 'user'
await cfg.property.read_only()
def test_mandatory_empty():
od1 = make_description()
cfg = Config(od1)
cfg.option('str1').value.set('')
assert cfg.option('str1').owner.get() == 'user'
cfg.property.read_only()
prop = []
try:
await cfg.option('str1').value.get()
cfg.option('str1').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_multi_none():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str3').value.set([None])
assert await cfg.option('str3').owner.get() == 'user'
await cfg.property.read_only()
def test_mandatory_multi_none():
od1 = make_description()
cfg = Config(od1)
cfg.option('str3').value.set([None])
assert cfg.option('str3').owner.get() == 'user'
cfg.property.read_only()
prop = []
try:
await cfg.option('str3').value.get()
cfg.option('str3').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
await cfg.property.read_write()
await cfg.option('str3').value.set(['yes', None])
assert await cfg.option('str3').owner.get() == 'user'
await cfg.property.read_only()
cfg.property.read_write()
cfg.option('str3').value.set(['yes', None])
assert cfg.option('str3').owner.get() == 'user'
cfg.property.read_only()
prop = []
try:
await cfg.option('str3').value.get()
cfg.option('str3').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_multi_empty():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str3').value.set([])
assert await cfg.option('str3').owner.get() == 'user'
await cfg.property.read_only()
def test_mandatory_multi_empty():
od1 = make_description()
cfg = Config(od1)
cfg.option('str3').value.set([])
assert cfg.option('str3').owner.get() == 'user'
cfg.property.read_only()
prop = []
try:
await cfg.option('str3').value.get()
cfg.option('str3').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
#
await cfg.property.read_write()
await cfg.option('str3').value.set([''])
assert await cfg.option('str3').owner.get() == 'user'
await cfg.property.read_only()
cfg.property.read_write()
cfg.option('str3').value.set([''])
assert cfg.option('str3').owner.get() == 'user'
cfg.property.read_only()
prop = []
try:
await cfg.option('str3').value.get()
cfg.option('str3').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
#
await cfg.property.read_write()
await cfg.option('str3').value.set(['yes', ''])
assert await cfg.option('str3').owner.get() == 'user'
await cfg.property.read_only()
cfg.property.read_write()
cfg.option('str3').value.set(['yes', ''])
assert cfg.option('str3').owner.get() == 'user'
cfg.property.read_only()
prop = []
try:
await cfg.option('str3').value.get()
cfg.option('str3').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_multi_append():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str3').value.set(['yes'])
await cfg.property.read_write()
ret = await cfg.option('str3').value.get()
def test_mandatory_multi_append():
od1 = make_description()
cfg = Config(od1)
cfg.option('str3').value.set(['yes'])
cfg.property.read_write()
ret = cfg.option('str3').value.get()
ret.append(None)
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_disabled():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str1').value.get()
await cfg.option('str1').property.add('disabled')
await cfg.property.read_only()
def test_mandatory_disabled():
od1 = make_description()
cfg = Config(od1)
cfg.option('str1').value.get()
cfg.option('str1').property.add('disabled')
cfg.property.read_only()
pop = []
try:
await cfg.option('str1').value.get()
cfg.option('str1').value.get()
except PropertiesOptionError as err:
prop = err.proptype
search_prop = {'disabled'}
assert set(prop) == search_prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_unicode():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('unicode2').value.get()
await cfg.property.read_only()
def test_mandatory_unicode():
od1 = make_description()
cfg = Config(od1)
cfg.option('unicode2').value.get()
cfg.property.read_only()
prop = []
try:
await cfg.option('unicode2').value.get()
cfg.option('unicode2').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
await cfg.property.read_write()
await cfg.option('unicode2').value.set(u'')
await cfg.property.read_only()
cfg.property.read_write()
cfg.option('unicode2').value.set(u'')
cfg.property.read_only()
prop = []
try:
await cfg.option('unicode2').value.get()
cfg.option('unicode2').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_ro():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str').value.set('')
await cfg.property.read_only()
def test_mandatory_warnings_ro():
od1 = make_description()
cfg = Config(od1)
cfg.option('str').value.set('')
cfg.property.read_only()
proc = []
try:
await cfg.option('str').value.get()
cfg.option('str').value.get()
except PropertiesOptionError as err:
prop = err.proptype
assert 'mandatory' in prop
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'unicode2', 'str3']
await cfg.property.read_write()
await cfg.option('str').value.set('a')
await cfg.property.read_only()
assert list(await cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
assert not await list_sessions()
assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2', 'str3']
cfg.property.read_write()
cfg.option('str').value.set('a')
cfg.property.read_only()
assert list(cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_rw():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str').value.set('')
await cfg.property.read_write()
await cfg.option('str').value.get()
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'unicode2', 'str3']
await cfg.option('str').value.set('a')
assert list(await cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
assert not await list_sessions()
def test_mandatory_warnings_rw():
od1 = make_description()
cfg = Config(od1)
cfg.option('str').value.set('')
cfg.property.read_write()
cfg.option('str').value.get()
assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2', 'str3']
cfg.option('str').value.set('a')
assert list(cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_disabled():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str').value.set('')
await cfg.property.read_write()
await cfg.option('str').value.get()
assert set(await cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
await cfg.option('str').property.add('disabled')
assert set(await cfg.value.mandatory()) == {'str1', 'unicode2', 'str3'}
assert not await list_sessions()
def test_mandatory_warnings_disabled():
od1 = make_description()
cfg = Config(od1)
cfg.option('str').value.set('')
cfg.property.read_write()
cfg.option('str').value.get()
assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
cfg.option('str').property.add('disabled')
assert set(cfg.value.mandatory()) == {'str1', 'unicode2', 'str3'}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_hidden():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str').value.set('')
await cfg.property.read_write()
await cfg.permissive.add('hidden')
await cfg.option('str').value.get()
assert set(await cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
await cfg.option('str').property.add('hidden')
assert set(await cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
assert not await list_sessions()
def test_mandatory_warnings_hidden():
od1 = make_description()
cfg = Config(od1)
cfg.option('str').value.set('')
cfg.property.read_write()
cfg.permissive.add('hidden')
cfg.option('str').value.get()
assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
cfg.option('str').property.add('hidden')
assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_frozen():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.option('str').value.set('')
await cfg.property.read_write()
await cfg.option('str').value.get()
assert set(await cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
await cfg.option('str').property.add('frozen')
await cfg.property.read_only()
assert set(await cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
assert not await list_sessions()
def test_mandatory_warnings_frozen():
od1 = make_description()
cfg = Config(od1)
cfg.option('str').value.set('')
cfg.property.read_write()
cfg.option('str').value.get()
assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
cfg.option('str').property.add('frozen')
cfg.property.read_only()
assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_leader():
def test_mandatory_leader():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
properties=('mandatory', ))
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg:
await cfg.property.read_only()
od1 = OptionDescription('o', '', [interface1])
cfg = Config(od1)
cfg.property.read_only()
with pytest.raises(PropertiesOptionError):
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
with pytest.raises(PropertiesOptionError):
await cfg.value.dict()
assert not await list_sessions()
cfg.value.dict()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_leader():
def test_mandatory_leader_sub():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
properties=('mandatory', ))
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg:
assert list(await cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
assert not await list_sessions()
od1 = OptionDescription('o', '', [interface1])
od2 = OptionDescription('o', '', [od1])
cfg = Config(od2)
cfg.property.read_only()
with pytest.raises(PropertiesOptionError):
cfg.option('o.ip_admin_eth0.ip_admin_eth0').value.get()
with pytest.raises(PropertiesOptionError):
cfg.value.dict()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_leader_empty():
def test_mandatory_warnings_leader():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
properties=('mandatory', ))
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
od1 = OptionDescription('o', '', [interface1])
cfg = Config(od1)
assert list(cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
# assert not list_sessions()
def test_mandatory_leader_empty():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg:
await cfg.property.read_write()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
od1 = OptionDescription('o', '', [interface1])
cfg = Config(od1)
cfg.property.read_write()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
#
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([undefined])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [None]
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
await cfg.property.read_only()
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
cfg.property.read_only()
with pytest.raises(PropertiesOptionError):
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
with pytest.raises(PropertiesOptionError):
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
cfg.property.read_write()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
#
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([''])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['']
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
await cfg.property.read_only()
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
cfg.property.read_only()
with pytest.raises(PropertiesOptionError):
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
with pytest.raises(PropertiesOptionError):
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
await cfg.property.read_write()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
cfg.property.read_write()
#
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
await cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
cfg.property.read_write()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
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() == None
#
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip2'])
await cfg.property.read_only()
cfg.property.read_write()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip2'])
cfg.property.read_only()
with pytest.raises(PropertiesOptionError):
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert not await list_sessions()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
cfg.property.read_write()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_leader_empty():
def test_mandatory_warnings_leader_empty():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([undefined])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [None]
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert list(await cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
od1 = OptionDescription('o', '', [interface1])
cfg = Config(od1)
cfg.property.read_write()
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
assert list(cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
#
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([''])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['']
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert list(await cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
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
assert list(cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
#
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
assert list(await cfg.value.mandatory()) == []
assert not await list_sessions()
cfg.property.read_write()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
assert list(cfg.value.mandatory()) == []
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_follower():
def test_mandatory_follower():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True, properties=('mandatory', ))
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg:
await cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [],
od1 = OptionDescription('o', '', [interface1])
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': [],
'ip_admin_eth0.netmask_admin_eth0': []}
#
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
await cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
cfg.property.read_write()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
cfg.property.read_only()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
with pytest.raises(PropertiesOptionError):
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
#
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('')
await cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
cfg.property.read_write()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('')
cfg.property.read_only()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
with pytest.raises(PropertiesOptionError):
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
#
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('ip')
await cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == 'ip'
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['ip'],
cfg.property.read_write()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('ip')
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'],
'ip_admin_eth0.netmask_admin_eth0': ['ip']}
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_follower():
def test_mandatory_warnings_follower():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True, properties=('mandatory', ))
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg:
await cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
od1 = OptionDescription('o', '', [interface1])
cfg = Config(od1)
cfg.property.read_only()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
#
await cfg.property.read_write()
assert list(await cfg.value.mandatory()) == []
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
assert list(await cfg.value.mandatory()) == ['ip_admin_eth0.netmask_admin_eth0']
assert not await list_sessions()
cfg.property.read_write()
assert list(cfg.value.mandatory()) == []
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
assert list(cfg.value.mandatory()) == ['ip_admin_eth0.netmask_admin_eth0']
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_symlink():
descr = make_description_sym()
async with await Config(descr) as cfg:
await cfg.option('str').value.set('')
await cfg.property.read_write()
await cfg.option('str').value.get()
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'str3']
await cfg.option('str').property.add('frozen')
await cfg.property.read_only()
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'str3']
assert not await list_sessions()
def test_mandatory_warnings_symlink():
od1 = make_description_sym()
cfg = Config(od1)
cfg.option('str').value.set('')
cfg.property.read_write()
cfg.option('str').value.get()
assert list(cfg.value.mandatory()) == ['str', 'str1', 'str3']
cfg.option('str').property.add('frozen')
cfg.property.read_only()
assert list(cfg.value.mandatory()) == ['str', 'str1', 'str3']
# assert not list_sessions()
#@pytest.mark.asyncio
#async def test_mandatory_warnings_validate():
# descr = make_description3()
# cfg = await Config(descr)
# await cfg.option('str').value.set('')
# raises(ValueError, "list(await cfg.value.mandatory())")
# await cfg.option('str').value.set('test')
# raises(ValueError, "list(await cfg.value.mandatory())")
def test_mandatory_warnings_validate_empty():
od1 = make_description2()
cfg = Config(od1)
cfg.option('str').value.set('')
cfg.property.read_only()
assert list(cfg.value.mandatory()) == ['str', 'str1', 'str3']
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_validate_empty():
descr = make_description2()
async with await Config(descr) as cfg:
await cfg.option('str').value.set('')
await cfg.property.read_only()
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'str3']
assert not await list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_requires():
def test_mandatory_warnings_requires():
stroption = StrOption('str', 'Test string option', default="abc",
properties=('mandatory', ))
stroption1 = StrOption('str1', 'Test string option',
@ -615,22 +594,21 @@ async def test_mandatory_warnings_requires():
'expected': ParamValue('yes'),
'no_condition_is_invalid': ParamValue(True)}))
stroption3 = StrOption('str3', 'Test string option', multi=True, properties=(mandatory_property,))
descr = OptionDescription('tiram', '', [stroption, stroption1, stroption2, stroption3])
async with await Config(descr) as cfg:
await cfg.option('str').value.set('')
await cfg.property.read_write()
await cfg.option('str').value.get()
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'unicode2']
await cfg.property.read_only()
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'unicode2']
await cfg.property.read_write()
await cfg.option('str').value.set('yes')
assert list(await cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
assert not await list_sessions()
od1 = OptionDescription('tiram', '', [stroption, stroption1, stroption2, stroption3])
cfg = Config(od1)
cfg.option('str').value.set('')
cfg.property.read_write()
cfg.option('str').value.get()
assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2']
cfg.property.read_only()
assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2']
cfg.property.read_write()
cfg.option('str').value.set('yes')
assert list(cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_requires_leadership():
def test_mandatory_warnings_requires_leadership():
stroption = StrOption('str', 'Test string option', default="abc",
properties=('mandatory', ))
stroption1 = StrOption('str1', 'Test string option', multi=True)
@ -642,18 +620,17 @@ async def test_mandatory_warnings_requires_leadership():
'default': ParamValue('mandatory')}))
stroption2 = StrOption('str2', 'Test string option', multi=True, properties=(mandatory_property,))
leadership = Leadership('leader', 'leadership', [stroption1, stroption2])
descr = OptionDescription('tiram', '', [stroption, leadership])
async with await Config(descr) as cfg:
await cfg.option('str').value.set('')
await cfg.option('leader.str1').value.set(['str'])
assert list(await cfg.value.mandatory()) == ['str']
await cfg.option('str').value.set('yes')
assert list(await cfg.value.mandatory()) == ['leader.str2']
assert not await list_sessions()
od1 = OptionDescription('tiram', '', [stroption, leadership])
cfg = Config(od1)
cfg.option('str').value.set('')
cfg.option('leader.str1').value.set(['str'])
assert list(cfg.value.mandatory()) == ['str']
cfg.option('str').value.set('yes')
assert list(cfg.value.mandatory()) == ['leader.str2']
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_warnings_requires_leadership_follower():
def test_mandatory_warnings_requires_leadership_follower():
stroption = StrOption('str', 'Test string option', multi=True)
stroption1 = StrOption('str1', 'Test string option', multi=True)
mandatory_property = Calculation(calc_value,
@ -664,22 +641,21 @@ async def test_mandatory_warnings_requires_leadership_follower():
'default': ParamValue('mandatory')}))
stroption2 = StrOption('str2', 'Test string option', multi=True, properties=(mandatory_property,))
leadership = Leadership('leader', 'leadership', [stroption, stroption1, stroption2])
descr = OptionDescription('tiram', '', [leadership])
async with await Config(descr) as cfg:
await cfg.option('leader.str').value.set(['str'])
assert list(await cfg.value.mandatory()) == []
await cfg.option('leader.str1', 0).value.set('yes')
assert list(await cfg.value.mandatory()) == ['leader.str2']
assert not await list_sessions()
od1 = OptionDescription('tiram', '', [leadership])
cfg = Config(od1)
cfg.option('leader.str').value.set(['str'])
assert list(cfg.value.mandatory()) == []
cfg.option('leader.str1', 0).value.set('yes')
assert list(cfg.value.mandatory()) == ['leader.str2']
# assert not list_sessions()
@pytest.mark.asyncio
async def test_mandatory_od_disabled():
def test_mandatory_od_disabled():
descr = make_description()
descr = OptionDescription('od', '', [descr])
async with await Config(descr) as cfg:
await cfg.property.read_only()
assert list(await cfg.value.mandatory()) == ['tiram.str1', 'tiram.unicode2', 'tiram.str3']
await cfg.option('tiram').property.add('disabled')
assert list(await cfg.value.mandatory()) == []
assert not await list_sessions()
od1 = OptionDescription('od', '', [descr])
cfg = Config(od1)
cfg.property.read_only()
assert list(cfg.value.mandatory()) == ['tiram.str1', 'tiram.unicode2', 'tiram.str3']
cfg.option('tiram').property.add('disabled')
assert list(cfg.value.mandatory()) == []
# assert not list_sessions()

1787
tests/test_metaconfig.py
View file

File diff suppressed because it is too large Load diff

1559
tests/test_mixconfig.py
View file

File diff suppressed because it is too large Load diff

101
tests/test_multi_parents.py
View file

@ -1,10 +1,9 @@
from tiramisu import IntOption, OptionDescription, MetaConfig, list_sessions
from tiramisu import IntOption, OptionDescription, MetaConfig
from tiramisu.error import ConfigError
import pytest
from .config import delete_sessions, event_loop
async def make_metaconfig():
def make_metaconfig():
i1 = IntOption('i1', '')
i2 = IntOption('i2', '', default=1)
i3 = IntOption('i3', '')
@ -13,85 +12,79 @@ async def make_metaconfig():
i6 = IntOption('i6', '', properties=('disabled',))
od1 = OptionDescription('od1', '', [i1, i2, i3, i4, i5, i6])
od2 = OptionDescription('od2', '', [od1])
return await MetaConfig([], optiondescription=od2, session_id='metacfg1', delete_old_session=True)
return MetaConfig([], optiondescription=od2, name='metacfg1')
@pytest.mark.asyncio
async def test_multi_parents_path():
def test_multi_parents_path():
"""
metacfg1 (1) ---
| -- cfg1
metacfg2 (2) ---
"""
metacfg1 = await make_metaconfig()
cfg1 = await metacfg1.config.new(type='config', session_id="cfg1")
metacfg2 = await MetaConfig([cfg1], session_id='metacfg2', delete_old_session=True)
metacfg1 = make_metaconfig()
cfg1 = metacfg1.config.new(type='config', name="cfg1")
metacfg2 = MetaConfig([cfg1], name='metacfg2')
#
assert await metacfg1.config.path() == 'metacfg1'
assert await metacfg2.config.path() == 'metacfg2'
assert await cfg1.config.path() == 'metacfg2.metacfg1.cfg1'
await delete_sessions([metacfg1, metacfg2])
assert metacfg1.config.path() == 'metacfg1'
assert metacfg2.config.path() == 'metacfg2'
assert cfg1.config.path() == 'metacfg2.metacfg1.cfg1'
@pytest.mark.asyncio
async def test_multi_parents_path_same():
def test_multi_parents_path_same():
"""
--- metacfg2 (1) ---
metacfg1 --| | -- cfg1
--- metacfg3 (2) ---
"""
metacfg1 = await make_metaconfig()
metacfg2 = await metacfg1.config.new(type='metaconfig', session_id="metacfg2")
metacfg3 = await metacfg1.config.new(type='metaconfig', session_id="metacfg3")
cfg1 = await metacfg2.config.new(type='config', session_id="cfg1")
await metacfg3.config.add(cfg1)
metacfg1 = make_metaconfig()
metacfg2 = metacfg1.config.new(type='metaconfig', name="metacfg2")
metacfg3 = metacfg1.config.new(type='metaconfig', name="metacfg3")
cfg1 = metacfg2.config.new(type='config', name="cfg1")
metacfg3.config.add(cfg1)
#
assert await metacfg2.config.path() == 'metacfg1.metacfg2'
assert await metacfg3.config.path() == 'metacfg1.metacfg3'
assert await cfg1.config.path() == 'metacfg1.metacfg3.metacfg1.metacfg2.cfg1'
await metacfg1.option('od1.i1').value.set(1)
await metacfg3.option('od1.i1').value.set(2)
assert await cfg1.option('od1.i1').value.get() == 1
orideep = await cfg1.config.deepcopy(metaconfig_prefix="test_", session_id='test_cfg1')
assert metacfg2.config.path() == 'metacfg1.metacfg2'
assert metacfg3.config.path() == 'metacfg1.metacfg3'
assert cfg1.config.path() == 'metacfg1.metacfg3.metacfg1.metacfg2.cfg1'
metacfg1.option('od1.i1').value.set(1)
metacfg3.option('od1.i1').value.set(2)
assert cfg1.option('od1.i1').value.get() == 1
orideep = cfg1.config.deepcopy(metaconfig_prefix="test_", name='test_cfg1')
deep = orideep
while True:
try:
children = list(await deep.config.list())
children = list(deep.config.list())
except:
break
assert len(children) < 2
deep = children[0]
assert await deep.config.path() == 'test_metacfg3.test_metacfg1.test_metacfg2.test_cfg1'
assert await cfg1.option('od1.i1').value.get() == 1
await delete_sessions([metacfg1, orideep])
assert deep.config.path() == 'test_metacfg3.test_metacfg1.test_metacfg2.test_cfg1'
assert cfg1.option('od1.i1').value.get() == 1
@pytest.mark.asyncio
async def test_multi_parents_value():
metacfg1 = await make_metaconfig()
cfg1 = await metacfg1.config.new(type='config', session_id="cfg1")
metacfg2 = await MetaConfig([cfg1], session_id='metacfg2', delete_old_session=True)
def test_multi_parents_value():
metacfg1 = make_metaconfig()
cfg1 = metacfg1.config.new(type='config', name="cfg1")
metacfg2 = MetaConfig([cfg1], name='metacfg2')
#
assert await cfg1.option('od1.i1').value.get() == None
assert await cfg1.option('od1.i2').value.get() == 1
assert await cfg1.option('od1.i3').value.get() == None
assert cfg1.option('od1.i1').value.get() == None
assert cfg1.option('od1.i2').value.get() == 1
assert cfg1.option('od1.i3').value.get() == None
#
assert await metacfg1.option('od1.i1').value.get() == None
assert await metacfg1.option('od1.i2').value.get() == 1
assert await metacfg1.option('od1.i3').value.get() == None
assert metacfg1.option('od1.i1').value.get() == None
assert metacfg1.option('od1.i2').value.get() == 1
assert metacfg1.option('od1.i3').value.get() == None
#
assert await metacfg2.option('od1.i1').value.get() == None
assert await metacfg2.option('od1.i2').value.get() == 1
assert await metacfg2.option('od1.i3').value.get() == None
assert metacfg2.option('od1.i1').value.get() == None
assert metacfg2.option('od1.i2').value.get() == 1
assert metacfg2.option('od1.i3').value.get() == None
#
await metacfg1.option('od1.i3').value.set(3)
assert await metacfg1.option('od1.i3').value.get() == 3
assert await cfg1.option('od1.i3').value.get() == 3
assert await metacfg2.option('od1.i2').value.get() == 1
metacfg1.option('od1.i3').value.set(3)
assert metacfg1.option('od1.i3').value.get() == 3
assert cfg1.option('od1.i3').value.get() == 3
assert metacfg2.option('od1.i2').value.get() == 1
#
await metacfg2.option('od1.i2').value.set(4)
assert await metacfg2.option('od1.i2').value.get() == 4
assert await metacfg1.option('od1.i2').value.get() == 1
assert await cfg1.option('od1.i2').value.get() == 4
await delete_sessions([metacfg1, metacfg2])
metacfg2.option('od1.i2').value.set(4)
assert metacfg2.option('od1.i2').value.get() == 4
assert metacfg1.option('od1.i2').value.get() == 1
assert cfg1.option('od1.i2').value.get() == 4

239
tests/test_option.py
View file

@ -6,11 +6,11 @@ do_autopath()
import pytest
import warnings
from tiramisu.error import ValueWarning, APIError
from tiramisu.error import APIError, ConfigError
from tiramisu import IntOption, SymLinkOption, OptionDescription, Config, Calculation, groups, list_sessions
from tiramisu import IntOption, SymLinkOption, OptionDescription, Config, Calculation, groups
from tiramisu.i18n import _
from .config import event_loop
try:
groups.family
@ -22,8 +22,7 @@ def a_func():
return None
@pytest.mark.asyncio
async def test_option_valid_name():
def test_option_valid_name():
IntOption('test', '')
with pytest.raises(ValueError):
IntOption(1, "")
@ -31,22 +30,9 @@ async def test_option_valid_name():
with pytest.raises(ValueError):
SymLinkOption(1, i)
i = SymLinkOption("test1", i)
#
#
#@pytest.mark.asyncio
#async def test_option_unvalid_name():
# with pytest.raises(ValueError):
# IntOption('test.', '')
# with pytest.raises(ValueError):
# IntOption('test.val', '')
# with pytest.raises(ValueError):
# IntOption('.test', '')
# with pytest.raises(ValueError):
# OptionDescription('.test', '', [])
@pytest.mark.asyncio
async def test_option_get_information():
def test_option_get_information():
description = "it's ok"
string = 'some informations'
i = IntOption('test', description)
@ -60,14 +46,12 @@ async def test_option_get_information():
assert i.impl_get_information('doc') == description
@pytest.mark.asyncio
async def test_option_get_information_config():
def test_option_get_information_config():
description = "it's ok"
string = 'some informations'
i = IntOption('test', description)
od = OptionDescription('od', '', [i])
async with await Config(od) as cfg:
pass
cfg = Config(od)
with pytest.raises(ValueError):
i.impl_get_information('noinfo')
with pytest.raises(AttributeError):
@ -76,34 +60,46 @@ async def test_option_get_information_config():
i.impl_get_information('noinfo')
assert i.impl_get_information('noinfo', 'default') == 'default'
assert i.impl_get_information('doc') == description
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_option_get_information_default():
def test_option_unknown():
description = "it's ok"
string = 'some informations'
i = IntOption('test', description)
i.impl_set_information('noinfo', 'optdefault')
od = OptionDescription('od', '', [i])
async with await Config(od) as cfg:
cfg = Config(od)
#
assert await cfg.option('test').information.get('noinfo', 'falsedefault') == 'optdefault'
#
await cfg.option('test').information.set('noinfo', 'notdefault')
assert await cfg.option('test').information.get('noinfo', 'falsedefault') == 'notdefault'
assert not await list_sessions()
with pytest.raises(APIError):
cfg.option('test').unknown.get()
with pytest.raises(APIError):
# only choice
cfg.option('test').value.list()
@pytest.mark.asyncio
async def test_option_get_information_config2():
def test_option_get_information_default():
description = "it's ok"
string = 'some informations'
i = IntOption('test', description)
i.impl_set_information('noinfo', 'optdefault')
od = OptionDescription('od', '', [i])
cfg = Config(od)
#
assert cfg.option('test').information.get('noinfo', 'falsedefault') == 'optdefault'
#
cfg.option('test').information.set('noinfo', 'notdefault')
assert cfg.option('test').information.get('noinfo', 'falsedefault') == 'notdefault'
# assert not list_sessions()
def test_option_get_information_config2():
description = "it's ok"
string = 'some informations'
i = IntOption('test', description)
i.impl_set_information('info', string)
od = OptionDescription('od', '', [i])
async with await Config(od) as cfg:
pass
cfg = Config(od)
with pytest.raises(ValueError):
i.impl_get_information('noinfo')
with pytest.raises(AttributeError):
@ -113,11 +109,10 @@ async def test_option_get_information_config2():
i.impl_get_information('noinfo')
assert i.impl_get_information('noinfo', 'default') == 'default'
assert i.impl_get_information('doc') == description
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_optiondescription_get_information():
def test_optiondescription_get_information():
description = "it's ok"
string = 'some informations'
o = OptionDescription('test', description, [])
@ -127,34 +122,31 @@ async def test_optiondescription_get_information():
o.impl_get_information('noinfo')
assert o.impl_get_information('noinfo', 'default') == 'default'
assert o.impl_get_information('doc') == description
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_option_isoptiondescription():
def test_option_isoptiondescription():
i = IntOption('test', '')
od = OptionDescription('od', '', [i])
od = OptionDescription('od', '', [od])
async with await Config(od) as cfg:
assert await cfg.option('od').option.isoptiondescription()
assert not await cfg.option('od.test').option.isoptiondescription()
assert not await list_sessions()
cfg = Config(od)
assert cfg.option('od').option.isoptiondescription()
assert not cfg.option('od.test').option.isoptiondescription()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_option_double():
def test_option_double():
i = IntOption('test', '')
od = OptionDescription('od1', '', [i])
od = OptionDescription('od2', '', [od])
od = OptionDescription('od3', '', [od])
async with await Config(od) as cfg:
assert await cfg.option('od2.od1.test').value.get() is None
assert await cfg.option('od2').option('od1').option('test').value.get() is None
assert not await list_sessions()
cfg = Config(od)
assert cfg.option('od2.od1.test').value.get() is None
assert cfg.option('od2').option('od1').option('test').value.get() is None
# assert not list_sessions()
@pytest.mark.asyncio
async def test_option_multi():
def test_option_multi():
IntOption('test', '', multi=True)
IntOption('test', '', multi=True, default_multi=1)
IntOption('test', '', default=[1], multi=True, default_multi=1)
@ -164,39 +156,30 @@ async def test_option_multi():
#unvalid default_multi
with pytest.raises(ValueError):
IntOption('test', '', multi=True, default_multi='yes')
assert not await list_sessions()
# assert not list_sessions()
#@pytest.mark.asyncio
#async def test_option_multi_legacy():
# #not default_multi with callback
# #with pytest.raises(ValueError):
# IntOption('test', '', multi=True, default_multi=1, callback=a_func)")
@pytest.mark.asyncio
async def test_unknown_option():
def test_unknown_option():
i = IntOption('test', '')
od1 = OptionDescription('od', '', [i])
od2 = OptionDescription('od', '', [od1])
async with await Config(od2) as cfg:
cfg = Config(od2)
# test is an option, not an optiondescription
with pytest.raises(TypeError):
await cfg.option('od.test.unknown').value.get()
cfg.option('od.test.unknown').value.get()
# unknown is an unknown option
with pytest.raises(AttributeError):
await cfg.option('unknown').value.get()
cfg.option('unknown').value.get()
# unknown is an unknown option
with pytest.raises(AttributeError):
await cfg.option('od.unknown').value.get()
cfg.option('od.unknown').value.get()
# unknown is an unknown optiondescription
with pytest.raises(AttributeError):
await cfg.option('od.unknown.suboption').value.get()
assert not await list_sessions()
cfg.option('od.unknown.suboption').value.get()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_optiondescription_list():
def test_optiondescription_list():
groups.notfamily1 = groups.GroupType('notfamily1')
i = IntOption('test', '')
i2 = IntOption('test', '')
@ -206,30 +189,29 @@ async def test_optiondescription_list():
od3.impl_set_group_type(groups.notfamily1)
od2 = OptionDescription('od', '', [od1, od3])
od4 = OptionDescription('od', '', [od2])
async with await Config(od4) as cfg:
assert len(list(await cfg.option('od').list('option'))) == 0
assert len(list(await cfg.option('od').list('optiondescription'))) == 2
assert len(list(await cfg.option('od').list('optiondescription', group_type=groups.family))) == 1
assert len(list(await cfg.option('od').list('optiondescription', group_type=groups.notfamily1))) == 1
assert len(list(await cfg.option('od.od').list('option'))) == 1
assert len(list(await cfg.option('od.od2').list('option'))) == 1
cfg = Config(od4)
assert len(list(cfg.option('od').list('option'))) == 0
assert len(list(cfg.option('od').list('optiondescription'))) == 2
assert len(list(cfg.option('od').list('optiondescription', group_type=groups.family))) == 1
assert len(list(cfg.option('od').list('optiondescription', group_type=groups.notfamily1))) == 1
assert len(list(cfg.option('od.od').list('option'))) == 1
assert len(list(cfg.option('od.od2').list('option'))) == 1
try:
list(await cfg.option('od').list('unknown'))
list(cfg.option('od').list('unknown'))
except AssertionError:
pass
else:
raise Exception('must raise')
try:
list(await cfg.option('od').list('option', group_type='toto'))
list(cfg.option('od').list('option', group_type='toto'))
except AssertionError:
pass
else:
raise Exception('must raise')
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_optiondescription_group():
def test_optiondescription_group():
groups.notfamily = groups.GroupType('notfamily')
i = IntOption('test', '')
i2 = IntOption('test', '')
@ -238,28 +220,27 @@ async def test_optiondescription_group():
od3 = OptionDescription('od2', '', [i2])
od3.impl_set_group_type(groups.notfamily)
od2 = OptionDescription('od', '', [od1, od3])
async with await Config(od2) as cfg:
assert len(list(await cfg.option.list('option'))) == 0
assert len(list(await cfg.option.list('optiondescription'))) == 2
assert len(list(await cfg.option.list('optiondescription', group_type=groups.family))) == 1
assert len(list(await cfg.option.list('optiondescription', group_type=groups.notfamily))) == 1
cfg = Config(od2)
assert len(list(cfg.option.list('option'))) == 0
assert len(list(cfg.option.list('optiondescription'))) == 2
assert len(list(cfg.option.list('optiondescription', group_type=groups.family))) == 1
assert len(list(cfg.option.list('optiondescription', group_type=groups.notfamily))) == 1
try:
list(await cfg.option.list('unknown'))
list(cfg.option.list('unknown'))
except AssertionError:
pass
else:
raise Exception('must raise')
try:
list(await cfg.option.list('option', group_type='toto'))
list(cfg.option.list('option', group_type='toto'))
except AssertionError:
pass
else:
raise Exception('must raise')
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_optiondescription_group_redefined():
def test_optiondescription_group_redefined():
try:
groups.notfamily = groups.GroupType('notfamily')
except:
@ -269,59 +250,77 @@ async def test_optiondescription_group_redefined():
od1.impl_set_group_type(groups.family)
with pytest.raises(ValueError):
od1.impl_set_group_type(groups.notfamily)
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_optiondescription_group_leadership():
def test_optiondescription_group_leadership():
i = IntOption('test', '')
od1 = OptionDescription('od', '', [i])
with pytest.raises(ConfigError):
od1.impl_set_group_type(groups.leadership)
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_asign_optiondescription():
def test_asign_optiondescription():
i = IntOption('test', '')
od1 = OptionDescription('od', '', [i])
od2 = OptionDescription('od', '', [od1])
async with await Config(od2) as cfg:
cfg = Config(od2)
with pytest.raises(APIError):
await cfg.option('od').value.set('test')
cfg.option('od').value.set('test')
with pytest.raises(APIError):
await cfg.option('od').value.reset()
assert not await list_sessions()
cfg.option('od').value.reset()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_intoption():
def test_intoption():
i1 = IntOption('test1', 'description', min_number=3)
i2 = IntOption('test2', 'description', max_number=3)
od = OptionDescription('od', '', [i1, i2])
async with await Config(od) as cfg:
i3 = IntOption('test3', 'description', min_number=3, max_number=6, warnings_only=True)
od = OptionDescription('od', '', [i1, i2, i3])
cfg = Config(od)
with pytest.raises(ValueError):
await cfg.option('test1').value.set(2)
await cfg.option('test1').value.set(3)
await cfg.option('test1').value.set(4)
await cfg.option('test2').value.set(2)
await cfg.option('test2').value.set(3)
cfg.option('test1').value.set(2)
cfg.option('test1').value.set(3)
assert cfg.option('test1').value.valid() is True
cfg.option('test1').value.set(4)
cfg.option('test2').value.set(2)
cfg.option('test2').value.set(3)
with pytest.raises(ValueError):
await cfg.option('test2').value.set(4)
assert not await list_sessions()
cfg.option('test2').value.set(4)
warnings.simplefilter("always", ValueWarning)
with warnings.catch_warnings(record=True) as w:
cfg.option('test3').value.set(2)
assert cfg.option('test3').value.valid() is True
assert len(w) == 1
with warnings.catch_warnings(record=True) as w:
cfg.option('test3').value.set(7)
assert cfg.option('test3').value.valid() is True
cfg.option('test3').value.set(4)
assert cfg.option('test3').value.valid() is True
assert len(w) == 1
# assert not list_sessions()
@pytest.mark.asyncio
async def test_get_display_type():
def test_get_display_type():
i1 = IntOption('test1', 'description', min_number=3)
assert i1.get_display_type() == _('integer')
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_option_not_in_config():
def test_option_not_in_config():
i1 = IntOption('test1', 'description', min_number=3)
with pytest.raises(AttributeError):
i1.impl_getpath()
assert not await list_sessions()
# assert not list_sessions()
def test_option_unknown_func():
i1 = IntOption('test1', 'description', min_number=3)
i2 = IntOption('test2', 'description', max_number=3)
i3 = IntOption('test3', 'description', min_number=3, max_number=6, warnings_only=True)
od = OptionDescription('od', '', [i1, i2, i3])
cfg = Config(od)
with pytest.raises(APIError):
cfg.option('test1').value.unknown()

1785
tests/test_option_callback.py
View file

File diff suppressed because it is too large Load diff

321
tests/test_option_default.py
View file

@ -6,9 +6,8 @@ import pytest
from tiramisu.setting import owners
from tiramisu.error import PropertiesOptionError, ConfigError, LeadershipError
from tiramisu import IntOption, FloatOption, StrOption, ChoiceOption, \
BoolOption, OptionDescription, Leadership, Config, undefined, delete_session
from tiramisu.storage import list_sessions
from .config import config_type, get_config, event_loop
BoolOption, OptionDescription, Leadership, Config, undefined
from .config import config_type, get_config
owners.addowner("frozenmultifollower")
@ -40,8 +39,7 @@ def make_description():
#____________________________________________________________
# default values
@pytest.mark.asyncio
async def test_default_is_none(config_type):
def test_default_is_none(config_type):
"""
Most constructors take a ``default`` argument that specifies the default
value of the option. If this argument is not supplied the default value is
@ -49,246 +47,233 @@ async def test_default_is_none(config_type):
"""
dummy1 = BoolOption('dummy1', 'doc dummy')
dummy2 = BoolOption('dummy2', 'doc dummy')
group = OptionDescription('group', '', [dummy1, dummy2])
async with await Config(group) as cfg:
cfg = await get_config(cfg, config_type)
od1 = OptionDescription('group', '', [dummy1, dummy2])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
# so when the default value is not set, there is actually a default value
assert await cfg.option('dummy1').value.get() is None
assert await cfg.option('dummy2').value.get() is None
assert not await list_sessions()
assert cfg.option('dummy1').value.get() is None
assert cfg.option('dummy2').value.get() is None
# assert not list_sessions()
@pytest.mark.asyncio
async def test_set_defaut_value_from_option_object():
def test_set_defaut_value_from_option_object():
"""Options have an available default setting and can give it back"""
b = BoolOption("boolean", "", default=False)
assert b.impl_getdefault() is False
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_default_on_freeze():
def test_force_default_on_freeze():
"a frozen option wich is forced returns his default"
dummy1 = BoolOption('dummy1', 'doc dummy', default=False, properties=('force_default_on_freeze',))
dummy2 = BoolOption('dummy2', 'doc dummy', default=True)
group = OptionDescription('group', '', [dummy1, dummy2])
async with await Config(group) as cfg_ori:
await cfg_ori.property.read_write()
od1 = OptionDescription('group', '', [dummy1, dummy2])
cfg_ori = Config(od1)
cfg_ori.property.read_write()
cfg = cfg_ori
# FIXME cfg = await get_config(cfg_ori, config_type)
owner = await cfg.owner.get()
await cfg.option('dummy1').value.set(True)
await cfg.option('dummy2').value.set(False)
assert await cfg.option('dummy1').owner.get() == owner
assert await cfg.option('dummy2').owner.get() == owner
# FIXME cfg = get_config(cfg_ori, config_type)
owner = cfg.owner.get()
cfg.option('dummy1').value.set(True)
cfg.option('dummy2').value.set(False)
assert cfg.option('dummy1').owner.get() == owner
assert cfg.option('dummy2').owner.get() == owner
# if config_type == 'tiramisu-api':
# await cfg.send()
await cfg_ori.option('dummy1').property.add('frozen')
await cfg_ori.option('dummy2').property.add('frozen')
# cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy1').value.get() is False
assert await cfg.option('dummy2').value.get() is False
assert await cfg.option('dummy1').owner.isdefault()
assert await cfg.option('dummy2').owner.get() == owner
# cfg.send()
cfg_ori.option('dummy1').property.add('frozen')
cfg_ori.option('dummy2').property.add('frozen')
# cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy1').value.get() is False
assert cfg.option('dummy2').value.get() is False
assert cfg.option('dummy1').owner.isdefault()
assert cfg.option('dummy2').owner.get() == owner
# if config_type == 'tiramisu-api':
# await cfg.send()
# cfg.send()
with pytest.raises(PropertiesOptionError):
await cfg_ori.option('dummy2').owner.set('frozen')
# cfg = await get_config(cfg_ori, config_type)
cfg_ori.option('dummy2').owner.set('frozen')
# cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('dummy1').value.reset()
cfg.option('dummy1').value.reset()
# if config_type == 'tiramisu-api':
# await cfg.send()
await cfg_ori.option('dummy1').property.pop('frozen')
# cfg = await get_config(cfg_ori, config_type)
await cfg.option('dummy1').value.reset()
# cfg.send()
cfg_ori.option('dummy1').property.remove('frozen')
# cfg = get_config(cfg_ori, config_type)
cfg.option('dummy1').value.reset()
# if config_type == 'tiramisu-api':
# await cfg.send()
await cfg.option('dummy1').property.add('frozen')
# cfg = await get_config(cfg_ori, config_type)
# cfg.send()
cfg.option('dummy1').property.add('frozen')
# cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('dummy2').owner.set('frozen')
assert not await list_sessions()
cfg.option('dummy2').owner.set('frozen')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_default_on_freeze_multi():
def test_force_default_on_freeze_multi():
dummy1 = BoolOption('dummy1', 'doc dummy', default=[False], properties=('force_default_on_freeze',), multi=True)
dummy2 = BoolOption('dummy2', 'doc dummy', default=[True], multi=True)
group = OptionDescription('group', '', [dummy1, dummy2])
async with await Config(group) as cfg_ori:
await cfg_ori.property.read_write()
od1 = OptionDescription('group', '', [dummy1, dummy2])
cfg_ori = Config(od1)
cfg_ori.property.read_write()
cfg = cfg_ori
# FIXME cfg = await get_config(cfg_ori, config_type)
await cfg.option('dummy1').value.set([undefined, True])
await cfg.option('dummy2').value.set([undefined, False])
owner = await cfg.owner.get()
assert await cfg.option('dummy1').owner.get() == owner
assert await cfg.option('dummy2').owner.get() == owner
# FIXME cfg = get_config(cfg_ori, config_type)
cfg.option('dummy1').value.set([undefined, True])
cfg.option('dummy2').value.set([undefined, False])
owner = cfg.owner.get()
assert cfg.option('dummy1').owner.get() == owner
assert cfg.option('dummy2').owner.get() == owner
# if config_type == 'tiramisu-api':
# await cfg.send()
await cfg_ori.option('dummy1').property.add('frozen')
await cfg_ori.option('dummy2').property.add('frozen')
# cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy1').value.get() == [False]
assert await cfg.option('dummy2').value.get() == [True, False]
assert await cfg.option('dummy1').owner.isdefault()
assert await cfg.option('dummy2').owner.get() == owner
# cfg.send()
cfg_ori.option('dummy1').property.add('frozen')
cfg_ori.option('dummy2').property.add('frozen')
# cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy1').value.get() == [False]
assert cfg.option('dummy2').value.get() == [True, False]
assert cfg.option('dummy1').owner.isdefault()
assert cfg.option('dummy2').owner.get() == owner
# if config_type == 'tiramisu-api':
# await cfg.send()
# cfg.send()
with pytest.raises(PropertiesOptionError):
await cfg_ori.option('dummy2').owner.set('owner')
# cfg = await get_config(cfg_ori, config_type)
cfg_ori.option('dummy2').owner.set('owner')
# cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('dummy2').value.reset()
cfg.option('dummy2').value.reset()
# if config_type == 'tiramisu-api':
# await cfg.send()
await cfg_ori.option('dummy1').property.pop('frozen')
# cfg = await get_config(cfg_ori, config_type)
await cfg.option('dummy1').value.reset()
assert not await list_sessions()
# cfg.send()
cfg_ori.option('dummy1').property.remove('frozen')
# cfg = get_config(cfg_ori, config_type)
cfg.option('dummy1').value.reset()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_default_on_freeze_leader():
def test_force_default_on_freeze_leader():
dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_default_on_freeze',))
dummy2 = BoolOption('dummy2', 'Test string option', multi=True)
descr = Leadership("dummy1", "", [dummy1, dummy2])
descr = OptionDescription("root", "", [descr])
od1 = OptionDescription("root", "", [descr])
with pytest.raises(ConfigError):
await Config(descr, session_id='error')
await delete_session('error')
assert not await list_sessions()
Config(od1)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_metaconfig_on_freeze_leader():
def test_force_metaconfig_on_freeze_leader():
dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_metaconfig_on_freeze',))
dummy2 = BoolOption('dummy2', 'Test string option', multi=True)
descr = Leadership("dummy1", "", [dummy1, dummy2])
descr = OptionDescription("root", "", [descr])
od1 = OptionDescription("root", "", [descr])
with pytest.raises(ConfigError):
await Config(descr, session_id='error')
await delete_session('error')
assert not await list_sessions()
Config(od1)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_default_on_freeze_leader_frozen():
def test_force_default_on_freeze_leader_frozen():
dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_default_on_freeze', 'frozen'))
dummy2 = BoolOption('dummy2', 'Test string option', multi=True)
descr = Leadership("dummy1", "", [dummy1, dummy2])
descr = OptionDescription("root", "", [descr])
async with await Config(descr) as cfg:
od1 = OptionDescription("root", "", [descr])
cfg = Config(od1)
with pytest.raises(LeadershipError):
await cfg.option('dummy1.dummy1').property.pop('frozen')
assert not await list_sessions()
cfg.option('dummy1.dummy1').property.remove('frozen')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_metaconfig_on_freeze_leader_frozen():
def test_force_metaconfig_on_freeze_leader_frozen():
dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_metaconfig_on_freeze', 'frozen'))
dummy2 = BoolOption('dummy2', 'Test string option', multi=True)
descr = Leadership("dummy1", "", [dummy1, dummy2])
descr = OptionDescription("root", "", [descr])
async with await Config(descr) as cfg:
od1 = OptionDescription("root", "", [descr])
cfg = Config(od1)
with pytest.raises(LeadershipError):
await cfg.option('dummy1.dummy1').property.pop('frozen')
assert not await list_sessions()
cfg.option('dummy1.dummy1').property.remove('frozen')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_force_default_on_freeze_follower(config_type):
def test_force_default_on_freeze_follower(config_type):
dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('notunique',))
dummy2 = BoolOption('dummy2', 'Test string option', multi=True, properties=('force_default_on_freeze',))
descr = Leadership("dummy1", "", [dummy1, dummy2])
descr = OptionDescription("root", "", [descr])
async with await Config(descr) as cfg_ori:
await cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type)
await cfg.option('dummy1.dummy1').value.set([True])
await cfg.option('dummy1.dummy2', 0).value.set(False)
assert await cfg.option('dummy1.dummy1').value.get() == [True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == False
assert await cfg.option('dummy1.dummy1').owner.get() == 'user'
assert await cfg.option('dummy1.dummy2', 0).owner.get() == 'user'
od1 = OptionDescription("root", "", [descr])
cfg_ori = Config(od1)
cfg_ori.property.read_write()
cfg = get_config(cfg_ori, config_type)
cfg.option('dummy1.dummy1').value.set([True])
cfg.option('dummy1.dummy2', 0).value.set(False)
assert cfg.option('dummy1.dummy1').value.get() == [True]
assert cfg.option('dummy1.dummy2', 0).value.get() == False
assert cfg.option('dummy1.dummy1').owner.get() == 'user'
assert cfg.option('dummy1.dummy2', 0).owner.get() == 'user'
#
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.option('dummy1.dummy2').property.add('frozen')
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy1.dummy1').value.get() == [True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == None
assert await cfg.option('dummy1.dummy1').owner.get() == 'user'
assert await cfg.option('dummy1.dummy2', 0).owner.isdefault()
cfg.send()
cfg_ori.option('dummy1.dummy2').property.add('frozen')
cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy1.dummy1').value.get() == [True]
assert cfg.option('dummy1.dummy2', 0).value.get() == None
assert cfg.option('dummy1.dummy1').owner.get() == 'user'
assert cfg.option('dummy1.dummy2', 0).owner.isdefault()
if config_type == 'tiramisu-api':
await cfg.send()
cfg.send()
with pytest.raises(PropertiesOptionError):
await cfg_ori.option('dummy1.dummy2', 0).owner.set('frozenmultifollower')
cfg = await get_config(cfg_ori, config_type)
cfg_ori.option('dummy1.dummy2', 0).owner.set('frozenmultifollower')
cfg = get_config(cfg_ori, config_type)
#
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.option('dummy1.dummy2').property.pop('frozen')
cfg = await get_config(cfg_ori, config_type)
await cfg.option('dummy1.dummy1').value.set([True, True])
await cfg.option('dummy1.dummy2', 1).value.set(False)
assert await cfg.option('dummy1.dummy1').value.get() == [True, True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == False
assert await cfg.option('dummy1.dummy2', 1).value.get() == False
cfg.send()
cfg_ori.option('dummy1.dummy2').property.remove('frozen')
cfg = get_config(cfg_ori, config_type)
cfg.option('dummy1.dummy1').value.set([True, True])
cfg.option('dummy1.dummy2', 1).value.set(False)
assert cfg.option('dummy1.dummy1').value.get() == [True, True]
assert cfg.option('dummy1.dummy2', 0).value.get() == False
assert cfg.option('dummy1.dummy2', 1).value.get() == False
#
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.option('dummy1.dummy2').property.add('frozen')
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy1.dummy1').value.get() == [True, True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == None
assert await cfg.option('dummy1.dummy2', 1).value.get() == None
cfg.send()
cfg_ori.option('dummy1.dummy2').property.add('frozen')
cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy1.dummy1').value.get() == [True, True]
assert cfg.option('dummy1.dummy2', 0).value.get() == None
assert cfg.option('dummy1.dummy2', 1).value.get() == None
#
await cfg.option('dummy1.dummy1').value.pop(1)
assert await cfg.option('dummy1.dummy1').value.get() == [True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == None
cfg.option('dummy1.dummy1').value.pop(1)
assert cfg.option('dummy1.dummy1').value.get() == [True]
assert cfg.option('dummy1.dummy2', 0).value.get() == None
#
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.option('dummy1.dummy2').property.pop('frozen')
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy1.dummy1').value.get() == [True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == False
cfg.send()
cfg_ori.option('dummy1.dummy2').property.remove('frozen')
cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy1.dummy1').value.get() == [True]
assert cfg.option('dummy1.dummy2', 0).value.get() == False
#
await cfg.option('dummy1.dummy1').value.set([True, True])
assert await cfg.option('dummy1.dummy2', 0).value.get() == False
assert await cfg.option('dummy1.dummy2', 1).value.get() == None
assert not await list_sessions()
cfg.option('dummy1.dummy1').value.set([True, True])
assert cfg.option('dummy1.dummy2', 0).value.get() == False
assert cfg.option('dummy1.dummy2', 1).value.get() == None
# assert not list_sessions()
@pytest.mark.asyncio
async def test_overrides_changes_option_value(config_type):
def test_overrides_changes_option_value(config_type):
"with config.override(), the default is changed and the value is changed"
descr = OptionDescription("test", "", [
od1 = OptionDescription("test", "", [
BoolOption("b", "", default=False)])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
await cfg.option('b').value.set(True)
assert not await list_sessions()
cfg = Config(od1)
cfg = get_config(cfg, config_type)
cfg.option('b').value.set(True)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choice_with_no_default(config_type):
descr = OptionDescription("test", "", [
def test_choice_with_no_default(config_type):
od1 = OptionDescription("test", "", [
ChoiceOption("backend", "", ("c", "cli"))])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('backend').value.get() is None
await cfg.option('backend').value.set('c')
assert not await list_sessions()
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('backend').value.get() is None
cfg.option('backend').value.set('c')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_choice_with_default(config_type):
descr = OptionDescription("test", "", [
def test_choice_with_default(config_type):
od1 = OptionDescription("test", "", [
ChoiceOption("backend", "", ("c", "cli"), default="cli")])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('backend').value.get() == 'cli'
assert not await list_sessions()
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('backend').value.get() == 'cli'
# assert not list_sessions()

294
tests/test_option_owner.py
View file

@ -7,8 +7,7 @@ from tiramisu.setting import owners, groups
from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
StrOption, OptionDescription, SymLinkOption, Leadership, Config
from tiramisu.error import ConfigError, ConstError, PropertiesOptionError, APIError
from tiramisu.storage import list_sessions
from .config import config_type, get_config, event_loop
from .config import config_type, get_config
owners.addowner("readonly2")
@ -37,217 +36,214 @@ def make_description():
return descr
@pytest.mark.asyncio
async def test_default_owner(config_type):
def test_default_owner(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default'
await cfg.option('dummy').value.set(True)
owner = await cfg.owner.get()
assert await cfg.option('dummy').owner.get() == owner
assert not await list_sessions()
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('dummy').value.get() is False
assert cfg.option('dummy').owner.get() == 'default'
cfg.option('dummy').value.set(True)
owner = cfg.owner.get()
assert cfg.option('dummy').owner.get() == owner
# assert not list_sessions()
@pytest.mark.asyncio
async def test_hidden_owner():
def test_owner_unknown_func(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False)
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
with pytest.raises(APIError):
owner = cfg.option('dummy').owner.unknown()
# assert not list_sessions()
def test_hidden_owner():
gcdummy = BoolOption('dummy', 'dummy', default=False, properties=('hidden',))
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg:
await cfg.property.read_write()
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg = Config(od1)
cfg.property.read_write()
#with pytest.raises(PropertiesOptionError):
# await cfg.forcepermissive.option('dummy').owner.get()
# cfg.forcepermissive.option('dummy').owner.get()
#with pytest.raises(PropertiesOptionError):
# await cfg.option('dummy').owner.isdefault()
# cfg.option('dummy').owner.isdefault()
#with pytest.raises(PropertiesOptionError):
# await cfg.forcepermissive.option('dummy').owner.isdefault()
await cfg.permissive.add('hidden')
await cfg.forcepermissive.option('dummy').value.get()
await cfg.forcepermissive.option('dummy').owner.isdefault()
assert not await list_sessions()
# cfg.forcepermissive.option('dummy').owner.isdefault()
cfg.permissive.add('hidden')
cfg.forcepermissive.option('dummy').value.get()
cfg.forcepermissive.option('dummy').owner.isdefault()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_addowner(config_type):
def test_addowner(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg_ori:
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default'
assert await cfg.option('dummy').owner.isdefault()
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg_ori = Config(od1)
cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy').value.get() is False
assert cfg.option('dummy').owner.get() == 'default'
assert cfg.option('dummy').owner.isdefault()
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.owner.set('gen_config')
cfg = await get_config(cfg_ori, config_type)
await cfg.option('dummy').value.set(True)
assert await cfg.option('dummy').owner.get() == owners.gen_config
assert not await cfg.option('dummy').owner.isdefault()
assert not await list_sessions()
cfg.send()
cfg_ori.owner.set('gen_config')
cfg = get_config(cfg_ori, config_type)
cfg.option('dummy').value.set(True)
assert cfg.option('dummy').owner.get() == owners.gen_config
assert not cfg.option('dummy').owner.isdefault()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_addowner_multiple_time():
def test_addowner_multiple_time():
owners.addowner("testowner2")
with pytest.raises(ConstError):
owners.addowner("testowner2")
@pytest.mark.asyncio
async def test_delete_owner():
def test_delete_owner():
owners.addowner('deleted2')
with pytest.raises(ConstError):
del(owners.deleted2)
@pytest.mark.asyncio
async def test_owner_is_not_a_string(config_type):
def test_owner_is_not_a_string(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == owners.default
assert await cfg.option('dummy').owner.get() == 'default'
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('dummy').value.get() is False
assert cfg.option('dummy').owner.get() == owners.default
assert cfg.option('dummy').owner.get() == 'default'
if config_type == 'tiramisu':
assert isinstance(await cfg.option('dummy').owner.get(), owners.Owner)
await cfg.option('dummy').value.set(True)
assert await cfg.option('dummy').owner.get() == 'user'
assert not await list_sessions()
assert isinstance(cfg.option('dummy').owner.get(), owners.Owner)
cfg.option('dummy').value.set(True)
assert cfg.option('dummy').owner.get() == 'user'
# assert not list_sessions()
@pytest.mark.asyncio
async def test_setowner_without_valid_owner(config_type):
def test_setowner_without_valid_owner(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default'
assert not await list_sessions()
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('dummy').value.get() is False
assert cfg.option('dummy').owner.get() == 'default'
# assert not list_sessions()
@pytest.mark.asyncio
async def test_setowner_for_value(config_type):
def test_setowner_for_value(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg_ori:
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default'
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg_ori = Config(od1)
cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy').value.get() is False
assert cfg.option('dummy').owner.get() == 'default'
if config_type == 'tiramisu-api':
await cfg.send()
cfg.send()
with pytest.raises(ConfigError):
await cfg_ori.option('dummy').owner.set('new2')
cfg = await get_config(cfg_ori, config_type)
await cfg.option('dummy').value.set(False)
assert await cfg.option('dummy').owner.get() == owners.user
cfg_ori.option('dummy').owner.set('new2')
cfg = get_config(cfg_ori, config_type)
cfg.option('dummy').value.set(False)
assert cfg.option('dummy').owner.get() == owners.user
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.option('dummy').owner.set('new2')
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy').owner.get() == owners.new2
assert not await list_sessions()
cfg.send()
cfg_ori.option('dummy').owner.set('new2')
cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy').owner.get() == owners.new2
# assert not list_sessions()
@pytest.mark.asyncio
async def test_setowner_forbidden(config_type):
def test_setowner_forbidden(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg_ori:
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default'
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg_ori = Config(od1)
cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy').value.get() is False
assert cfg.option('dummy').owner.get() == 'default'
if config_type == 'tiramisu-api':
await cfg.send()
cfg.send()
with pytest.raises(ValueError):
await cfg_ori.owner.set('default')
cfg = await get_config(cfg_ori, config_type)
await cfg.option('dummy').value.set(False)
cfg_ori.owner.set('default')
cfg = get_config(cfg_ori, config_type)
cfg.option('dummy').value.set(False)
if config_type == 'tiramisu-api':
await cfg.send()
cfg.send()
with pytest.raises(ValueError):
await cfg_ori.option('dummy').owner.set('default')
cfg = await get_config(cfg_ori, config_type)
assert not await list_sessions()
cfg_ori.option('dummy').owner.set('default')
cfg = get_config(cfg_ori, config_type)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_setowner_read_only(config_type):
def test_setowner_read_only(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg_ori:
await cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default'
await cfg.option('dummy').value.set(False)
assert await cfg.option('dummy').owner.get() == owners.user
od1 = OptionDescription('tiramisu', '', [gcdummy])
cfg_ori = Config(od1)
cfg_ori.property.read_write()
cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy').value.get() is False
assert cfg.option('dummy').owner.get() == 'default'
cfg.option('dummy').value.set(False)
assert cfg.option('dummy').owner.get() == owners.user
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.property.read_only()
cfg.send()
cfg_ori.property.read_only()
with pytest.raises(PropertiesOptionError):
await cfg_ori.option('dummy').owner.set('readonly2')
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('dummy').owner.get() == owners.user
assert not await list_sessions()
cfg_ori.option('dummy').owner.set('readonly2')
cfg = get_config(cfg_ori, config_type)
assert cfg.option('dummy').owner.get() == owners.user
# assert not list_sessions()
@pytest.mark.asyncio
async def test_setowner_optiondescription(config_type):
def test_setowner_optiondescription(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False)
descr1 = OptionDescription('tiramisu', '', [gcdummy])
descr = OptionDescription('tiramisu', '', [descr1])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
od1 = OptionDescription('tiramisu', '', [descr1])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
with pytest.raises(APIError):
await cfg.option('tiramisu').owner.get()
cfg.option('tiramisu').owner.get()
with pytest.raises(APIError):
await cfg.option('tiramisu').owner.set('user')
assert not await list_sessions()
cfg.option('tiramisu').owner.set('user')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_setowner_symlinkoption(config_type):
def test_setowner_symlinkoption(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False)
s = SymLinkOption('symdummy', gcdummy)
descr1 = OptionDescription('tiramisu', '', [gcdummy, s])
descr = OptionDescription('tiramisu', '', [descr1])
async with await Config(descr) as cfg_ori:
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('tiramisu.symdummy').owner.isdefault()
await cfg.option('tiramisu.dummy').value.set(True)
assert not await cfg.option('tiramisu.symdummy').owner.isdefault()
od1 = OptionDescription('tiramisu', '', [descr1])
cfg_ori = Config(od1)
cfg = get_config(cfg_ori, config_type)
assert cfg.option('tiramisu.symdummy').owner.isdefault()
cfg.option('tiramisu.dummy').value.set(True)
assert not cfg.option('tiramisu.symdummy').owner.isdefault()
if config_type == 'tiramisu-api':
await cfg.send()
cfg.send()
with pytest.raises(ConfigError):
await cfg_ori.option('tiramisu.symdummy').owner.set('user')
assert not await list_sessions()
cfg_ori.option('tiramisu.symdummy').owner.set('user')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_owner_leadership(config_type):
def test_owner_leadership(config_type):
b = IntOption('int', 'Test int option', default=[0], multi=True)
c = StrOption('str', 'Test string option', multi=True)
descr = Leadership("int", "", [b, c])
od = OptionDescription('od', '', [descr])
async with await Config(od) as cfg_ori:
od1 = OptionDescription('od', '', [descr])
cfg_ori = Config(od1)
with pytest.raises(ConfigError):
await cfg_ori.option('int.str', 0).owner.set('user')
cfg = await get_config(cfg_ori, config_type)
cfg_ori.option('int.str', 0).owner.set('user')
cfg = get_config(cfg_ori, config_type)
await cfg.option('int.int').value.set([0, 1])
await cfg.option('int.str', 0).value.set('yes')
assert not await cfg.option('int.str', 0).owner.isdefault()
assert await cfg.option('int.str', 1).owner.isdefault()
cfg.option('int.int').value.set([0, 1])
cfg.option('int.str', 0).value.set('yes')
assert not cfg.option('int.str', 0).owner.isdefault()
assert cfg.option('int.str', 1).owner.isdefault()
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.option('int.str', 0).owner.set('user')
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('int.str', 0).owner.get() == owners.user
assert await cfg.option('int.str', 1).owner.isdefault()
assert await cfg.option('int.str', 0).value.get() == 'yes'
assert await cfg.option('int.str', 1).value.get() == None
assert not await list_sessions()
cfg.send()
cfg_ori.option('int.str', 0).owner.set('user')
cfg = get_config(cfg_ori, config_type)
assert cfg.option('int.str', 0).owner.get() == owners.user
assert cfg.option('int.str', 1).owner.isdefault()
assert cfg.option('int.str', 0).value.get() == 'yes'
assert cfg.option('int.str', 1).value.get() == None
# assert not list_sessions()

868
tests/test_option_setting.py
View file

File diff suppressed because it is too large Load diff

176
tests/test_option_type.py
View file

@ -9,8 +9,7 @@ from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
PasswordOption, StrOption, DateOption, OptionDescription, Config, \
Calculation, Params, ParamOption, ParamValue, calc_value
from tiramisu.error import PropertiesOptionError
from tiramisu.storage import list_sessions
from .config import config_type, get_config, event_loop
from .config import config_type, get_config
def make_description():
@ -49,73 +48,70 @@ def make_description():
# ____________________________________________________________
@pytest.mark.asyncio
async def test_is_hidden(config_type):
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
assert not 'frozen' in await cfg.forcepermissive.option('gc.dummy').property.get()
cfg = await get_config(cfg, config_type)
def test_is_hidden(config_type):
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
assert not 'frozen' in cfg.forcepermissive.option('gc.dummy').property.get()
cfg = get_config(cfg, config_type)
# setattr
with pytest.raises(PropertiesOptionError):
await cfg.option('gc.dummy').value.get() == False
cfg.option('gc.dummy').value.get() == False
# getattr
with pytest.raises(PropertiesOptionError):
await cfg.option('gc.dummy').value.get()
assert not await list_sessions()
cfg.option('gc.dummy').value.get()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_group_is_hidden(config_type):
descr = make_description()
async with await Config(descr) as cfg_ori:
await cfg_ori.property.read_write()
await cfg_ori.option('gc').property.add('hidden')
cfg = await get_config(cfg_ori, config_type)
def test_group_is_hidden(config_type):
od1 = make_description()
cfg_ori = Config(od1)
cfg_ori.property.read_write()
cfg_ori.option('gc').property.add('hidden')
cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('gc.dummy').value.get()
cfg.option('gc.dummy').value.get()
if config_type == 'tiramisu-api':
await cfg.send()
assert 'hidden' in await cfg_ori.forcepermissive.option('gc').property.get()
cfg = await get_config(cfg_ori, config_type)
cfg.send()
assert 'hidden' in cfg_ori.forcepermissive.option('gc').property.get()
cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('gc.float').value.get()
cfg.option('gc.float').value.get()
# manually set the subconfigs to "show"
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.forcepermissive.option('gc').property.pop('hidden')
cfg = await get_config(cfg_ori, config_type)
assert not 'hidden' in await cfg.option('gc').property.get()
assert await cfg.option('gc.float').value.get() == 2.3
cfg.send()
cfg_ori.forcepermissive.option('gc').property.remove('hidden')
cfg = get_config(cfg_ori, config_type)
assert not 'hidden' in cfg.option('gc').property.get()
assert cfg.option('gc.float').value.get() == 2.3
#dummy est en hide
prop = []
try:
await cfg.option('gc.dummy').value.set(False)
cfg.option('gc.dummy').value.set(False)
except PropertiesOptionError as err:
prop = err.proptype
if config_type == 'tiramisu-api':
assert 'disabled' in prop
else:
assert 'hidden' in prop
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_group_is_hidden_multi(config_type):
descr = make_description()
async with await Config(descr) as cfg_ori:
await cfg_ori.property.read_write()
await cfg_ori.option('objspace').property.add('hidden')
cfg = await get_config(cfg_ori, config_type)
def test_group_is_hidden_multi(config_type):
od1 = make_description()
cfg_ori = Config(od1)
cfg_ori.property.read_write()
cfg_ori.option('objspace').property.add('hidden')
cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('objspace').value.get()
cfg.option('objspace').value.get()
if config_type == 'tiramisu-api':
await cfg.send()
assert 'hidden' in await cfg_ori.forcepermissive.option('objspace').property.get()
cfg = await get_config(cfg_ori, config_type)
cfg.send()
assert 'hidden' in cfg_ori.forcepermissive.option('objspace').property.get()
cfg = get_config(cfg_ori, config_type)
prop = []
try:
await cfg.option('objspace').value.set(['std'])
cfg.option('objspace').value.set(['std'])
except PropertiesOptionError as err:
prop = err.proptype
if config_type == 'tiramisu-api':
@ -123,76 +119,72 @@ async def test_group_is_hidden_multi(config_type):
else:
assert 'hidden' in prop
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.forcepermissive.option('objspace').property.pop('hidden')
cfg = await get_config(cfg_ori, config_type)
assert not 'hidden' in await cfg.option('objspace').property.get()
await cfg.option('objspace').value.set(['std', 'thunk'])
assert not await list_sessions()
cfg.send()
cfg_ori.forcepermissive.option('objspace').property.remove('hidden')
cfg = get_config(cfg_ori, config_type)
assert not 'hidden' in cfg.option('objspace').property.get()
cfg.option('objspace').value.set(['std', 'thunk'])
# assert not list_sessions()
@pytest.mark.asyncio
async def test_global_show(config_type):
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.forcepermissive.option('gc.dummy').property.add('hidden')
assert 'hidden' in await cfg.forcepermissive.option('gc.dummy').property.get()
cfg = await get_config(cfg, config_type)
def test_global_show(config_type):
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
cfg.forcepermissive.option('gc.dummy').property.add('hidden')
assert 'hidden' in cfg.forcepermissive.option('gc.dummy').property.get()
cfg = get_config(cfg, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('gc.dummy').value.get() == False
assert not await list_sessions()
cfg.option('gc.dummy').value.get() == False
# assert not list_sessions()
@pytest.mark.asyncio
async def test_with_many_subgroups(config_type):
descr = make_description()
async with await Config(descr) as cfg_ori:
def test_with_many_subgroups(config_type):
od1 = make_description()
cfg_ori = Config(od1)
#booltwo = config.unwrap_from_path('gc.subgroup.booltwo')
#setting = config.cfgimpl_get_settings()
cfg = await get_config(cfg_ori, config_type)
assert not 'hidden' in await cfg.option('gc.subgroup.booltwo').property.get()
assert await cfg.option('gc.subgroup.booltwo').value.get() is False
cfg = get_config(cfg_ori, config_type)
assert not 'hidden' in cfg.option('gc.subgroup.booltwo').property.get()
assert cfg.option('gc.subgroup.booltwo').value.get() is False
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.option('gc.subgroup.booltwo').property.add('hidden')
assert not await list_sessions()
cfg.send()
cfg_ori.option('gc.subgroup.booltwo').property.add('hidden')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_password_option(config_type):
def test_password_option(config_type):
o = PasswordOption('o', '')
d = OptionDescription('d', '', [o])
async with await Config(d) as cfg:
cfg = await get_config(cfg, config_type)
od1 = OptionDescription('d', '', [o])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
await cfg.option('o').value.set('a_valid_password')
cfg.option('o').value.set('a_valid_password')
with pytest.raises(ValueError):
await cfg.option('o').value.set(1)
assert not await list_sessions()
cfg.option('o').value.set(1)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_date_option(config_type):
def test_date_option(config_type):
o = DateOption('o', '')
d = OptionDescription('d', '', [o])
async with await Config(d) as cfg:
cfg = await get_config(cfg, config_type)
od1 = OptionDescription('d', '', [o])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
await cfg.option('o').value.set('2017-02-04')
await cfg.option('o').value.set('2017-2-4')
cfg.option('o').value.set('2017-02-04')
cfg.option('o').value.set('2017-2-4')
with pytest.raises(ValueError):
await cfg.option('o').value.set(1)
cfg.option('o').value.set(1)
with pytest.raises(ValueError):
await cfg.option('o').value.set('2017-13-20')
cfg.option('o').value.set('2017-13-20')
with pytest.raises(ValueError):
await cfg.option('o').value.set('2017-11-31')
cfg.option('o').value.set('2017-11-31')
with pytest.raises(ValueError):
await cfg.option('o').value.set('2017-12-32')
cfg.option('o').value.set('2017-12-32')
with pytest.raises(ValueError):
await cfg.option('o').value.set('2017-2-29')
cfg.option('o').value.set('2017-2-29')
with pytest.raises(ValueError):
await cfg.option('o').value.set('2-2-2017')
cfg.option('o').value.set('2-2-2017')
with pytest.raises(ValueError):
await cfg.option('o').value.set('2017/2/2')
assert not await list_sessions()
cfg.option('o').value.set('2017/2/2')
# assert not list_sessions()

1279
tests/test_option_validator.py
View file

File diff suppressed because it is too large Load diff

39
tests/test_option_with_special_name.py
View file

@ -5,8 +5,7 @@ do_autopath()
import pytest
from tiramisu import BoolOption, OptionDescription, ChoiceOption,\
IntOption, FloatOption, StrOption, Config
from tiramisu.storage import list_sessions
from .config import config_type, get_config, event_loop
from .config import config_type, get_config
def make_description():
@ -32,34 +31,26 @@ def make_description():
return descr
@pytest.mark.asyncio
async def test_root_config_answers_ok(config_type):
def test_root_config_answers_ok(config_type):
"if you hide the root config, the options in this namespace behave normally"
gcdummy = BoolOption('dummy', 'dummy', default=False)
boolop = BoolOption('boolop', 'Test boolean option op', default=True)
descr = OptionDescription('tiramisu', '', [gcdummy, boolop])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
#settings = await cfg.cfgimpl_get_settings()
od1 = OptionDescription('tiramisu', '', [gcdummy, boolop])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
#settings = cfg.cfgimpl_get_settings()
#settings.append('hidden')
assert await cfg.option('dummy').value.get() is False
assert await cfg.option('boolop').value.get() is True
assert not await list_sessions()
assert cfg.option('dummy').value.get() is False
assert cfg.option('boolop').value.get() is True
# assert not list_sessions()
#@pytest.mark.asyncio
# async def test_optname_shall_not_start_with_numbers():
# raises(ValueError, "gcdummy = BoolOption('123dummy', 'dummy', default=False)")
# raises(ValueError, "descr = OptionDescription('123tiramisu', '', [])")
#
#
@pytest.mark.asyncio
async def test_option_has_an_api_name(config_type):
def test_option_has_an_api_name(config_type):
b = BoolOption('impl_has_dependency', 'dummy', default=True)
descr = OptionDescription('tiramisu', '', [b])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('impl_has_dependency').value.get() is True
od1 = OptionDescription('tiramisu', '', [b])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('impl_has_dependency').value.get() is True
assert b.impl_has_dependency() is False
assert not await list_sessions()
# assert not list_sessions()

449
tests/test_permissive.py
View file

@ -5,9 +5,8 @@ do_autopath()
import pytest
from tiramisu import IntOption, StrOption, OptionDescription, Config
from tiramisu.error import PropertiesOptionError, ConfigError
from tiramisu.storage import list_sessions, delete_session
from .config import config_type, get_config, event_loop
from tiramisu.error import PropertiesOptionError, ConfigError, APIError
from .config import config_type, get_config
def make_description():
@ -16,428 +15,414 @@ def make_description():
return OptionDescription('od1', '', [u1, u2])
@pytest.mark.asyncio
async def test_permissive(config_type):
descr = make_description()
async with await Config(descr) as cfg_ori:
await cfg_ori.property.read_write()
await cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type)
def test_forcepermissive_and_unrestraint(config_type):
od1 = make_description()
cfg_ori = Config(od1)
cfg_ori.property.read_write()
cfg_ori.property.read_write()
cfg = get_config(cfg_ori, config_type)
with pytest.raises(APIError):
cfg_ori.unrestraint.forcepermissive.add('disabled')
def test_permissive(config_type):
od1 = make_description()
cfg_ori = Config(od1)
cfg_ori.property.read_write()
cfg_ori.property.read_write()
cfg = get_config(cfg_ori, config_type)
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.unrestraint.permissive.add('disabled')
await cfg_ori.unrestraint.permissive.pop('hidden')
assert await cfg_ori.unrestraint.permissive.get() == frozenset(['disabled'])
cfg = await get_config(cfg_ori, config_type)
cfg.send()
cfg_ori.unrestraint.permissive.add('disabled')
cfg_ori.unrestraint.permissive.remove('hidden')
assert cfg_ori.unrestraint.permissive.get() == frozenset(['disabled'])
cfg = get_config(cfg_ori, config_type)
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.property.add('permissive')
cfg = await get_config(cfg_ori, config_type)
await cfg.option('u1').value.get()
cfg.send()
cfg_ori.property.add('permissive')
cfg = get_config(cfg_ori, config_type)
cfg.option('u1').value.get()
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.property.pop('permissive')
cfg = await get_config(cfg_ori, config_type)
cfg.send()
cfg_ori.property.remove('permissive')
cfg = get_config(cfg_ori, config_type)
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_permissive_add(config_type):
descr = make_description()
async with await Config(descr) as cfg_ori:
await cfg_ori.property.read_write()
await cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type)
def test_permissive_add(config_type):
od1 = make_description()
cfg_ori = Config(od1)
cfg_ori.property.read_write()
cfg_ori.property.read_write()
cfg = get_config(cfg_ori, config_type)
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.unrestraint.permissive.add('disabled')
assert await cfg_ori.unrestraint.permissive.get() == frozenset(['hidden', 'disabled'])
cfg = await get_config(cfg_ori, config_type)
cfg.send()
cfg_ori.unrestraint.permissive.add('disabled')
assert cfg_ori.unrestraint.permissive.get() == frozenset(['hidden', 'disabled'])
cfg = get_config(cfg_ori, config_type)
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.property.add('permissive')
cfg = await get_config(cfg_ori, config_type)
await cfg.option('u1').value.get()
cfg.send()
cfg_ori.property.add('permissive')
cfg = get_config(cfg_ori, config_type)
cfg.option('u1').value.get()
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.property.pop('permissive')
cfg = await get_config(cfg_ori, config_type)
cfg.send()
cfg_ori.property.remove('permissive')
cfg = get_config(cfg_ori, config_type)
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_permissive_pop():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.property.read_write()
def test_permissive_pop():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
cfg.property.read_write()
props = frozenset()
try:
await cfg.forcepermissive.option('u1').value.get()
cfg.forcepermissive.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
await cfg.unrestraint.permissive.add('disabled')
assert await cfg.unrestraint.permissive.get() == frozenset(['hidden', 'disabled'])
await cfg.forcepermissive.option('u1').value.get()
await cfg.unrestraint.permissive.pop('disabled')
cfg.unrestraint.permissive.add('disabled')
assert cfg.unrestraint.permissive.get() == frozenset(['hidden', 'disabled'])
cfg.forcepermissive.option('u1').value.get()
cfg.unrestraint.permissive.remove('disabled')
props = frozenset()
try:
await cfg.forcepermissive.option('u1').value.get()
cfg.forcepermissive.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_permissive_reset():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
assert await cfg.unrestraint.permissive.get() == frozenset(['hidden'])
def test_permissive_reset():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
assert cfg.unrestraint.permissive.get() == frozenset(['hidden'])
#
await cfg.unrestraint.permissive.add('disabled')
await cfg.unrestraint.permissive.pop('hidden')
assert await cfg.unrestraint.permissive.get() == frozenset(['disabled'])
cfg.unrestraint.permissive.add('disabled')
cfg.unrestraint.permissive.remove('hidden')
assert cfg.unrestraint.permissive.get() == frozenset(['disabled'])
#
await cfg.unrestraint.permissive.reset()
assert await cfg.unrestraint.permissive.get() == frozenset()
assert not await list_sessions()
cfg.unrestraint.permissive.reset()
assert cfg.unrestraint.permissive.get() == frozenset()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_permissive_mandatory():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_only()
def test_permissive_mandatory():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_only()
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert frozenset(props) == frozenset(['disabled'])
await cfg.unrestraint.permissive.add('mandatory')
await cfg.unrestraint.permissive.add('disabled')
assert await cfg.unrestraint.permissive.get() == frozenset(['mandatory', 'disabled'])
await cfg.property.add('permissive')
await cfg.option('u1').value.get()
await cfg.property.pop('permissive')
cfg.unrestraint.permissive.add('mandatory')
cfg.unrestraint.permissive.add('disabled')
assert cfg.unrestraint.permissive.get() == frozenset(['mandatory', 'disabled'])
cfg.property.add('permissive')
cfg.option('u1').value.get()
cfg.property.remove('permissive')
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert frozenset(props) == frozenset(['disabled'])
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_permissive_frozen():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.unrestraint.permissive.pop('hidden')
await cfg.unrestraint.permissive.add('frozen')
await cfg.unrestraint.permissive.add('disabled')
assert await cfg.unrestraint.permissive.get() == frozenset(['frozen', 'disabled'])
assert await cfg.permissive.get() == frozenset(['frozen', 'disabled'])
def test_permissive_frozen():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
cfg.unrestraint.permissive.remove('hidden')
cfg.unrestraint.permissive.add('frozen')
cfg.unrestraint.permissive.add('disabled')
assert cfg.unrestraint.permissive.get() == frozenset(['frozen', 'disabled'])
assert cfg.permissive.get() == frozenset(['frozen', 'disabled'])
try:
await cfg.option('u1').value.set(1)
cfg.option('u1').value.set(1)
except PropertiesOptionError as err:
props = err.proptype
assert frozenset(props) == frozenset(['disabled'])
await cfg.property.add('permissive')
await cfg.option('u1').value.set(1)
assert await cfg.option('u1').value.get() == 1
await cfg.property.pop('permissive')
cfg.property.add('permissive')
cfg.option('u1').value.set(1)
assert cfg.option('u1').value.get() == 1
cfg.property.remove('permissive')
try:
await cfg.option('u1').value.set(1)
cfg.option('u1').value.set(1)
except PropertiesOptionError as err:
props = err.proptype
assert frozenset(props) == frozenset(['disabled'])
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_invalid_permissive():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
# FIXME with pytest.raises(TypeError):
# await cfg.unrestraint.permissive.set(['frozen', 'disabled'])")
assert not await list_sessions()
@pytest.mark.asyncio
async def test_forbidden_permissive():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
def test_forbidden_permissive():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
with pytest.raises(ConfigError):
await cfg.permissive.add('force_default_on_freeze')
cfg.permissive.add('force_default_on_freeze')
with pytest.raises(ConfigError):
await cfg.permissive.add('force_metaconfig_on_freeze')
assert not await list_sessions()
cfg.permissive.add('force_metaconfig_on_freeze')
# assert not list_sessions()
@pytest.mark.asyncio
async def test_permissive_option(config_type):
descr = make_description()
async with await Config(descr) as cfg_ori:
await cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type)
def test_permissive_option(config_type):
od1 = make_description()
cfg_ori = Config(od1)
cfg_ori.property.read_write()
cfg = get_config(cfg_ori, config_type)
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
props = frozenset()
try:
await cfg.option('u2').value.get()
cfg.option('u2').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.unrestraint.option('u1').permissive.set(frozenset(['disabled']))
cfg = await get_config(cfg_ori, config_type)
cfg.send()
cfg_ori.unrestraint.option('u1').permissive.set(frozenset(['disabled']))
cfg = get_config(cfg_ori, config_type)
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert frozenset(props) == frozenset()
props = frozenset()
try:
await cfg.option('u2').value.get()
cfg.option('u2').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.property.add('permissive')
cfg = await get_config(cfg_ori, config_type)
await cfg.option('u1').value.get()
cfg.send()
cfg_ori.property.add('permissive')
cfg = get_config(cfg_ori, config_type)
cfg.option('u1').value.get()
props = frozenset()
try:
await cfg.option('u2').value.get()
cfg.option('u2').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.property.pop('permissive')
cfg = await get_config(cfg_ori, config_type)
cfg.send()
cfg_ori.property.remove('permissive')
cfg = get_config(cfg_ori, config_type)
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert frozenset(props) == frozenset()
props = frozenset()
try:
await cfg.option('u2').value.get()
cfg.option('u2').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_permissive_option_cache():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
def test_permissive_option_cache():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
props = frozenset()
try:
await cfg.option('u2').value.get()
cfg.option('u2').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
await cfg.unrestraint.option('u1').permissive.set(frozenset(['disabled']))
cfg.unrestraint.option('u1').permissive.set(frozenset(['disabled']))
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert frozenset(props) == frozenset()
props = frozenset()
try:
await cfg.option('u2').value.get()
cfg.option('u2').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
await cfg.property.add('permissive')
await cfg.option('u1').value.get()
cfg.property.add('permissive')
cfg.option('u1').value.get()
props = frozenset()
try:
await cfg.option('u2').value.get()
cfg.option('u2').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
await cfg.property.pop('permissive')
cfg.property.remove('permissive')
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert frozenset(props) == frozenset()
props = frozenset()
try:
await cfg.option('u2').value.get()
cfg.option('u2').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert set(props) == {'disabled'}
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_permissive_option_mandatory():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_only()
def test_permissive_option_mandatory():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_only()
props = frozenset()
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert frozenset(props) == frozenset(['disabled'])
await cfg.unrestraint.option('u1').permissive.set(frozenset(['mandatory', 'disabled']))
assert await cfg.unrestraint.option('u1').permissive.get() == frozenset(['mandatory', 'disabled'])
await cfg.property.add('permissive')
await cfg.option('u1').value.get()
await cfg.property.pop('permissive')
cfg.unrestraint.option('u1').permissive.set(frozenset(['mandatory', 'disabled']))
assert cfg.unrestraint.option('u1').permissive.get() == frozenset(['mandatory', 'disabled'])
cfg.property.add('permissive')
cfg.option('u1').value.get()
cfg.property.remove('permissive')
try:
await cfg.option('u1').value.get()
cfg.option('u1').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert frozenset(props) == frozenset(['disabled'])
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_permissive_option_frozen():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.unrestraint.option('u1').permissive.set(frozenset(['frozen', 'disabled']))
await cfg.option('u1').value.set(1)
assert await cfg.option('u1').value.get() == 1
await cfg.property.add('permissive')
assert await cfg.option('u1').value.get() == 1
await cfg.property.pop('permissive')
assert await cfg.option('u1').value.get() == 1
assert not await list_sessions()
def test_permissive_option_frozen():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
cfg.unrestraint.option('u1').permissive.set(frozenset(['frozen', 'disabled']))
cfg.option('u1').value.set(1)
assert cfg.option('u1').value.get() == 1
cfg.property.add('permissive')
assert cfg.option('u1').value.get() == 1
cfg.property.remove('permissive')
assert cfg.option('u1').value.get() == 1
# assert not list_sessions()
@pytest.mark.asyncio
async def test_invalid_option_permissive():
descr = make_description()
async with await Config(descr) as cfg:
await cfg.property.read_write()
def test_invalid_option_permissive():
od1 = make_description()
cfg = Config(od1)
cfg.property.read_write()
with pytest.raises(TypeError):
await cfg.unrestraint.option('u1').permissive.set(['frozen', 'disabled'])
assert not await list_sessions()
cfg.unrestraint.option('u1').permissive.set(['frozen', 'disabled'])
# assert not list_sessions()
@pytest.mark.asyncio
async def test_remove_option_permissive(config_type):
def test_remove_option_permissive(config_type):
var1 = StrOption('var1', '', u'value', properties=('hidden',))
od1 = OptionDescription('od1', '', [var1])
descr = OptionDescription('rootod', '', [od1])
async with await Config(descr) as cfg_ori:
await cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type)
od2 = OptionDescription('rootod', '', [od1])
cfg_ori = Config(od2)
cfg_ori.property.read_write()
cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('od1.var1').value.get()
cfg.option('od1.var1').value.get()
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset(['hidden']))
assert await cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset(['hidden'])
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('od1.var1').value.get() == 'value'
cfg.send()
cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset(['hidden']))
assert cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset(['hidden'])
cfg = get_config(cfg_ori, config_type)
assert cfg.option('od1.var1').value.get() == 'value'
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset())
assert await cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset()
cfg = await get_config(cfg_ori, config_type)
cfg.send()
cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset())
assert cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset()
cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('od1.var1').value.get()
assert not await list_sessions()
cfg.option('od1.var1').value.get()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_reset_option_permissive(config_type):
def test_reset_option_permissive(config_type):
var1 = StrOption('var1', '', u'value', properties=('hidden',))
od1 = OptionDescription('od1', '', [var1])
descr = OptionDescription('rootod', '', [od1])
async with await Config(descr) as cfg_ori:
await cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type)
od2 = OptionDescription('rootod', '', [od1])
cfg_ori = Config(od2)
cfg_ori.property.read_write()
cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('od1.var1').value.get()
cfg.option('od1.var1').value.get()
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset(['hidden']))
assert await cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset(['hidden'])
cfg = await get_config(cfg_ori, config_type)
assert await cfg.option('od1.var1').value.get() == 'value'
cfg.send()
cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset(['hidden']))
assert cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset(['hidden'])
cfg = get_config(cfg_ori, config_type)
assert cfg.option('od1.var1').value.get() == 'value'
if config_type == 'tiramisu-api':
await cfg.send()
await cfg_ori.forcepermissive.option('od1.var1').permissive.reset()
assert await cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset()
cfg = await get_config(cfg_ori, config_type)
cfg.send()
cfg_ori.forcepermissive.option('od1.var1').permissive.reset()
assert cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset()
cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError):
await cfg.option('od1.var1').value.get()
assert not await list_sessions()
cfg.option('od1.var1').value.get()
# assert not list_sessions()

1004
tests/test_requires.py
View file

File diff suppressed because it is too large Load diff

50
tests/test_slots.py
View file

@ -16,8 +16,6 @@ from tiramisu.option import ChoiceOption, BoolOption, IntOption, FloatOption,\
StrOption, SymLinkOption, StrOption, IPOption, OptionDescription, \
PortOption, NetworkOption, NetmaskOption, DomainnameOption, EmailOption, \
URLOption, FilenameOption
from tiramisu.storage import list_sessions, delete_session
from .config import event_loop
def test_slots_option():
@ -86,8 +84,7 @@ def test_slots_option():
del c
@pytest.mark.asyncio
async def test_slots_option_readonly():
def test_slots_option_readonly():
a = ChoiceOption('a', '', ('a',))
b = BoolOption('b', '')
c = IntOption('c', '')
@ -118,8 +115,7 @@ async def test_slots_option_readonly():
o._name = 'o'
p._name = 'p'
q._name = 'q'
async with await Config(m) as cfg:
pass
Config(m)
with pytest.raises(AttributeError):
a._requires = 'a'
with pytest.raises(AttributeError):
@ -150,7 +146,7 @@ async def test_slots_option_readonly():
p._requires = 'p'
with pytest.raises(AttributeError):
q._requires = 'q'
assert not await list_sessions()
# assert not list_sessions()
#def test_slots_description():
@ -162,47 +158,45 @@ async def test_slots_option_readonly():
# assert slots == set(OptionDescription.__slots__)
@pytest.mark.asyncio
async def test_slots_config():
def test_slots_config():
od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1])
async with await Config(od2) as c:
cfg = Config(od2)
with pytest.raises(AttributeError):
c._config_bag.context.x = 1
cfg._config_bag.context.x = 1
with pytest.raises(AttributeError):
c._config_bag.context.cfgimpl_x = 1
option_bag = OptionBag()
option_bag.set_option(od2,
cfg._config_bag.context.x = 1
option_bag = OptionBag(od2,
'a',
ConfigBag(c._config_bag.context, None, None))
sc = await c._config_bag.context.get_subconfig(option_bag)
ConfigBag(cfg._config_bag.context, None, None),
properties=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 await list_sessions()
sc.x = 1
# assert not list_sessions()
@pytest.mark.asyncio
async def test_slots_setting():
def test_slots_setting():
od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1])
async with await Config(od2) as c:
s = c._config_bag.context.cfgimpl_get_settings()
cfg = Config(od2)
s = cfg._config_bag.context.get_settings()
s
with pytest.raises(AttributeError):
s.x = 1
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_slots_value():
def test_slots_value():
od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1])
async with await Config(od2) as c:
v = c._config_bag.context.cfgimpl_get_values()
cfg = Config(od2)
v = cfg._config_bag.context.get_values()
v
with pytest.raises(AttributeError):
v.x = 1
assert not await list_sessions()
# assert not list_sessions()

11
tests/test_state.py
View file

@ -5,8 +5,6 @@ from tiramisu import BoolOption, StrOption, SymLinkOption, OptionDescription, Dy
from pickle import dumps
import pytest
import sys, warnings
from tiramisu.storage import list_sessions
from .config import event_loop
def test_diff_opt():
@ -25,19 +23,18 @@ def test_diff_opt():
dumps(o1)
@pytest.mark.asyncio
async def test_diff_information_config():
def test_diff_information_config():
b = BoolOption('b', '')
b.impl_set_information('info', 'oh')
b.impl_set_information('info1', 'oh')
b.impl_set_information('info2', 'oh')
o = OptionDescription('o', '', [b])
o1 = OptionDescription('o1', '', [o])
async with await Config(o1) as cfg:
od1 = OptionDescription('o1', '', [o])
cfg = Config(od1)
c = cfg._config_bag.context
with pytest.raises(NotImplementedError):
dumps(c)
assert not await list_sessions()
# assert not list_sessions()
def test_only_optiondescription():

333
tests/test_storage.py
View file

@ -1,333 +0,0 @@
# coding: utf-8
from .autopath import do_autopath
do_autopath()
from py.test import raises
import pytest
from tiramisu.error import ConfigError
from tiramisu import Config, BoolOption, OptionDescription, Leadership, \
list_sessions, delete_session, default_storage, MetaConfig
from tiramisu.setting import groups, owners
from .config import event_loop
@pytest.mark.asyncio
async def test_non_persistent():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
async with await Config(o, session_id='test_non_persistent', delete_old_session=True) as cfg:
pass
assert not await list_sessions()
@pytest.mark.asyncio
async def test_list():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
async with await Config(o, session_id='test_non_persistent') as cfg:
await cfg.option('b').value.set(True)
assert 'test_non_persistent' in await list_sessions()
assert 'test_non_persistent' not in await list_sessions()
assert not await list_sessions()
@pytest.mark.asyncio
async def test_create_persistent():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
await Config(o, session_id='test_persistent')
await delete_session('test_persistent')
assert not await list_sessions()
@pytest.mark.asyncio
async def test_list_sessions_persistent():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
await cfg.option('b').value.set(True)
assert 'test_persistent' in await list_sessions()
await delete_session('test_persistent')
assert not await list_sessions()
@pytest.mark.asyncio
async def test_delete_session_persistent():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
await Config(o, session_id='test_persistent')
assert 'test_persistent' in await list_sessions()
await delete_session('test_persistent')
assert 'test_persistent' not in await list_sessions()
assert not await list_sessions()
@pytest.mark.asyncio
async def test_create_persistent_retrieve():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
assert await cfg.option('b').value.get() is None
await cfg.option('b').value.set(True)
assert await cfg.option('b').value.get() is True
del cfg
cfg = await Config(o, session_id='test_persistent')
assert await cfg.option('b').value.get() is True
assert 'test_persistent' in await list_sessions()
await delete_session(await cfg.session.id())
del cfg
cfg = await Config(o, session_id='test_persistent')
assert await cfg.option('b').value.get() is None
await delete_session(await cfg.session.id())
del cfg
assert not await list_sessions()
@pytest.mark.asyncio
async def test_two_persistent():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
cfg2 = await Config(o, session_id='test_persistent')
await cfg2.property.pop('cache')
assert await cfg.option('b').value.get() is None
assert await cfg2.option('b').value.get() is None
#
await cfg.option('b').value.set(False)
assert await cfg.option('b').value.get() is False
assert await cfg2.option('b').value.get() is False
#
await cfg.option('b').value.set(True)
assert await cfg.option('b').value.get() is True
assert await cfg2.option('b').value.get() is True
await delete_session('test_persistent')
assert not await list_sessions()
@pytest.mark.asyncio
async def test_create_persistent_retrieve_owner():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
assert await cfg.option('b').owner.isdefault()
await cfg.option('b').value.set(True)
assert await cfg.option('b').value.get()
assert await cfg.option('b').owner.get() == 'user'
##owners.addowner('persistentowner')
await cfg.option('b').owner.set('persistentowner')
assert await cfg.option('b').owner.get() == 'persistentowner'
del cfg
#
cfg = await Config(o, session_id='test_persistent')
await cfg.option('b').owner.set('persistentowner')
await delete_session(await cfg.session.id())
del cfg
#
cfg = await Config(o, session_id='test_persistent')
assert await cfg.option('b').value.get() is None
assert await cfg.option('b').owner.isdefault()
await delete_session(await cfg.session.id())
del cfg
assert not await list_sessions()
@pytest.mark.asyncio
async def test_create_persistent_retrieve_owner_leadership():
a = BoolOption('a', '', multi=True)
b = BoolOption('b', '', multi=True)
o = Leadership('a', '', [a, b])
o1 = OptionDescription('a', '', [o])
cfg = await Config(o1, session_id='test_persistent')
assert await cfg.option('a.a').owner.isdefault()
await cfg.option('a.a').value.set([True, False])
await cfg.option('a.b', 1).value.set(True)
assert await cfg.option('a.a').owner.get() == 'user'
assert await cfg.option('a.b', 0).owner.isdefault()
assert await cfg.option('a.b', 1).owner.get() == 'user'
#owners.addowner('persistentowner2')
await cfg.option('a.b', 1).owner.set('persistentowner2')
await cfg.option('a.b', 0).value.set(True)
assert await cfg.option('a.b', 0).owner.get() == 'user'
assert await cfg.option('a.b', 1).owner.get() == 'persistentowner2'
assert await cfg.option('a.a').value.get() == [True, False]
del cfg
#
cfg = await Config(o1, session_id='test_persistent')
assert await cfg.option('a.a').value.get() == [True, False]
assert await cfg.option('a.b', 0).owner.get() == 'user'
assert await cfg.option('a.b', 1).owner.get() == 'persistentowner2'
await delete_session(await cfg.session.id())
del cfg
#
cfg = await Config(o1, session_id='test_persistent')
assert await cfg.option('a.a').value.get() == []
await delete_session(await cfg.session.id())
del cfg
assert not await list_sessions()
@pytest.mark.asyncio
async def test_two_persistent_owner():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
await cfg.property.pop('cache')
cfg2 = await Config(o, session_id='test_persistent')
await cfg2.property.pop('cache')
assert await cfg.option('b').owner.isdefault()
assert await cfg2.option('b').owner.isdefault()
await cfg.option('b').value.set(False)
assert await cfg.option('b').owner.get() == 'user'
assert await cfg2.option('b').owner.get() == 'user'
await cfg.option('b').owner.set('persistent')
assert await cfg.option('b').owner.get() == 'persistent'
assert await cfg2.option('b').owner.get() == 'persistent'
await delete_session('test_persistent')
assert not await list_sessions()
@pytest.mark.asyncio
async def test_create_persistent_retrieve_information():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
await cfg.information.set('info', 'string')
assert await cfg.information.get('info') == 'string'
del cfg
#
cfg = await Config(o, session_id='test_persistent')
assert await cfg.information.get('info') == 'string'
await delete_session(await cfg.session.id())
del cfg
#
cfg = await Config(o, session_id='test_persistent')
assert await cfg.information.get('info', None) is None
await delete_session(await cfg.session.id())
del cfg
assert not await list_sessions()
@pytest.mark.asyncio
async def test_two_persistent_information():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
await cfg.property.pop('cache')
await cfg.information.set('info', 'string')
assert await cfg.information.get('info') == 'string'
cfg2 = await Config(o, session_id='test_persistent')
await cfg2.property.pop('cache')
assert await cfg2.information.get('info') == 'string'
await delete_session('test_persistent')
assert not await list_sessions()
@pytest.mark.asyncio
async def test_two_different_persistents():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
await cfg.property.pop('cache')
cfg2 = await Config(o, session_id='test_persistent2')
await cfg2.property.pop('cache')
await cfg.option('b').property.add('test')
assert await cfg.option('b').property.get() == {'test'}
assert await cfg2.option('b').property.get() == set()
assert await cfg.option('b').value.get() is None
assert await cfg2.option('b').value.get() is None
await cfg.option('b').value.set(True)
assert await cfg.option('b').value.get() == True
assert await cfg2.option('b').value.get() is None
await delete_session('test_persistent')
await delete_session('test_persistent2')
assert not await list_sessions()
@pytest.mark.asyncio
async def test_two_different_information():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
await cfg.information.set('a', 'a')
cfg2 = await Config(o, session_id='test_persistent2')
await cfg2.information.set('a', 'b')
assert await cfg.information.get('a') == 'a'
assert await cfg2.information.get('a') == 'b'
await delete_session('test_persistent')
await delete_session('test_persistent2')
assert not await list_sessions()
@pytest.mark.asyncio
async def test_exportation_importation():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
cfg2 = await Config(o, session_id='test_persistent2')
cfg3 = await Config(o, session_id='test_persistent3')
await cfg.owner.set('export')
assert await cfg.option('b').value.get() is None
await cfg.option('b').value.set(True)
assert await cfg.option('b').value.get() is True
assert await cfg.owner.get() == 'export'
del cfg
#
cfg = await Config(o, session_id='test_persistent')
assert await cfg.owner.get() == 'export'
assert await cfg.value.exportation() == [['b'], [None], [True], ['export']]
await cfg2.value.importation(await cfg.value.exportation())
assert await cfg.value.exportation() == [['b'], [None], [True], ['export']]
assert await cfg.owner.get() == 'export'
assert await cfg2.value.exportation() == [['b'], [None], [True], ['export']]
assert await cfg2.owner.get() == 'user'
del cfg2
#
cfg2 = await Config(o, session_id='test_persistent2')
assert await cfg2.value.exportation() == [['b'], [None], [True], ['export']]
assert await cfg2.owner.get() == 'user'
#
await cfg3.value.importation(await cfg.value.exportation(with_default_owner=True))
assert await cfg3.value.exportation() == [['b'], [None], [True], ['export']]
assert await cfg3.owner.get() == 'export'
del cfg3
#
cfg3 = await Config(o, session_id='test_persistent3')
assert await cfg3.value.exportation() == [['b'], [None], [True], ['export']]
assert await cfg3.owner.get() == 'export'
#
await delete_session('test_persistent')
await delete_session('test_persistent2')
await delete_session('test_persistent3')
assert not await list_sessions()
@pytest.mark.asyncio
async def test_create_persistent_context_property():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
await cfg.property.add('persistent')
del cfg
#
cfg = await Config(o, session_id='test_persistent')
assert 'persistent' in await cfg.property.get()
del cfg
await delete_session('test_persistent')
assert not await list_sessions()
@pytest.mark.asyncio
async def test_create_persistent_property():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = await Config(o, session_id='test_persistent')
await cfg.option('b').property.add('persistent')
del cfg
#
cfg = await Config(o, session_id='test_persistent')
assert 'persistent' in await cfg.option('b').property.get()
del cfg
await delete_session('test_persistent')

679
tests/test_submulti.py
View file

@ -9,8 +9,6 @@ from tiramisu.setting import groups, owners
from tiramisu import StrOption, IntOption, OptionDescription, submulti, Leadership, Config, \
MetaConfig, undefined, Params, ParamOption, Calculation
from tiramisu.error import LeadershipError
from tiramisu.storage import list_sessions
from .config import event_loop
def return_val(val=None):
@ -28,481 +26,456 @@ def return_list2(value=None):
return [['val', 'val']]
@pytest.mark.asyncio
async def test_unknown_multi():
def test_unknown_multi():
with pytest.raises(ValueError):
StrOption('multi', '', multi='unknown')
@pytest.mark.asyncio
async def test_submulti():
def test_submulti():
multi = StrOption('multi', '', multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
od = OptionDescription('od', '', [multi, multi2, multi3])
async with await Config(od) as cfg:
assert await cfg.option('multi').option.ismulti()
assert await cfg.option('multi').option.issubmulti()
assert await cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi').value.get() == []
assert await cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi3').value.get() == [['yes']]
assert await cfg.option('multi').owner.get() == owners.default
assert not await list_sessions()
od1 = OptionDescription('od', '', [multi, multi2, multi3])
cfg = Config(od1)
assert cfg.option('multi').option.ismulti()
assert cfg.option('multi').option.issubmulti()
assert cfg.option('multi').owner.get() == owners.default
assert cfg.option('multi').value.get() == []
assert cfg.option('multi').owner.get() == owners.default
assert cfg.option('multi').owner.get() == owners.default
assert cfg.option('multi3').value.get() == [['yes']]
assert cfg.option('multi').owner.get() == owners.default
# assert not list_sessions()
@pytest.mark.asyncio
async def test_submulti_default_multi_not_list():
def test_submulti_default_multi_not_list():
with pytest.raises(ValueError):
StrOption('multi2', '', default_multi='yes', multi=submulti)
@pytest.mark.asyncio
async def test_append_submulti():
def test_append_submulti():
multi = StrOption('multi', '', multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
od = OptionDescription('od', '', [multi, multi2, multi3])
async with await Config(od) as cfg:
owner = await cfg.owner.get()
assert await cfg.option('multi').value.get() == []
assert await cfg.option('multi').owner.get() == owners.default
await cfg.option('multi').value.set([undefined])
assert await cfg.option('multi').owner.get() == owner
assert await cfg.option('multi').value.get() == [[]]
await cfg.option('multi').value.set([undefined, ['no']])
assert await cfg.option('multi').value.get() == [[], ['no']]
od1 = OptionDescription('od', '', [multi, multi2, multi3])
cfg = Config(od1)
owner = cfg.owner.get()
assert cfg.option('multi').value.get() == []
assert cfg.option('multi').owner.get() == owners.default
cfg.option('multi').value.set([undefined])
assert cfg.option('multi').owner.get() == owner
assert cfg.option('multi').value.get() == [[]]
cfg.option('multi').value.set([undefined, ['no']])
assert cfg.option('multi').value.get() == [[], ['no']]
#
assert await cfg.option('multi2').value.get() == []
assert await cfg.option('multi2').owner.get() == owners.default
await cfg.option('multi2').value.set([undefined])
assert await cfg.option('multi2').owner.get() == owner
assert await cfg.option('multi2').value.get() == [['yes']]
await cfg.option('multi2').value.set([undefined, ['no']])
assert await cfg.option('multi2').value.get() == [['yes'], ['no']]
assert cfg.option('multi2').value.get() == []
assert cfg.option('multi2').owner.get() == owners.default
cfg.option('multi2').value.set([undefined])
assert cfg.option('multi2').owner.get() == owner
assert cfg.option('multi2').value.get() == [['yes']]
cfg.option('multi2').value.set([undefined, ['no']])
assert cfg.option('multi2').value.get() == [['yes'], ['no']]
#
assert await cfg.option('multi3').value.get() == [['yes']]
assert await cfg.option('multi3').owner.get() == owners.default
await cfg.option('multi3').value.set([undefined, undefined])
assert await cfg.option('multi3').owner.get() == owner
assert await cfg.option('multi3').value.get() == [['yes'], []]
await cfg.option('multi3').value.set([undefined, undefined, ['no']])
assert await cfg.option('multi3').value.get() == [['yes'], [], ['no']]
assert not await list_sessions()
assert cfg.option('multi3').value.get() == [['yes']]
assert cfg.option('multi3').owner.get() == owners.default
cfg.option('multi3').value.set([undefined, undefined])
assert cfg.option('multi3').owner.get() == owner
assert cfg.option('multi3').value.get() == [['yes'], []]
cfg.option('multi3').value.set([undefined, undefined, ['no']])
assert cfg.option('multi3').value.get() == [['yes'], [], ['no']]
# assert not list_sessions()
@pytest.mark.asyncio
async def test_append_unvalide_submulti():
def test_append_unvalide_submulti():
multi = StrOption('multi', '', multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
od = OptionDescription('od', '', [multi, multi2, multi3])
async with await Config(od) as cfg:
assert await cfg.option('multi').value.get() == []
assert await cfg.option('multi').owner.get() == owners.default
od1 = OptionDescription('od', '', [multi, multi2, multi3])
cfg = Config(od1)
assert cfg.option('multi').value.get() == []
assert cfg.option('multi').owner.get() == owners.default
with pytest.raises(ValueError):
await cfg.option('multi').value.set([[1]])
assert await cfg.option('multi').value.get() == []
assert await cfg.option('multi').owner.get() == owners.default
cfg.option('multi').value.set([[1]])
assert cfg.option('multi').value.get() == []
assert cfg.option('multi').owner.get() == owners.default
#
assert await cfg.option('multi2').value.get() == []
assert cfg.option('multi2').value.get() == []
with pytest.raises(ValueError):
await cfg.option('multi2').value.set(['no'])
assert await cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi2').value.get() == []
cfg.option('multi2').value.set(['no'])
assert cfg.option('multi').owner.get() == owners.default
assert cfg.option('multi2').value.get() == []
#
assert await cfg.option('multi3').value.get() == [['yes']]
assert await cfg.option('multi3').owner.get() == owners.default
assert cfg.option('multi3').value.get() == [['yes']]
assert cfg.option('multi3').owner.get() == owners.default
with pytest.raises(ValueError):
await cfg.option('multi3').value.set([[1]])
assert await cfg.option('multi3').value.get() == [['yes']]
assert await cfg.option('multi3').owner.get() == owners.default
assert not await list_sessions()
cfg.option('multi3').value.set([[1]])
assert cfg.option('multi3').value.get() == [['yes']]
assert cfg.option('multi3').owner.get() == owners.default
# assert not list_sessions()
@pytest.mark.asyncio
async def test_pop_submulti():
def test_pop_submulti():
multi = StrOption('multi', '', multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
od = OptionDescription('od', '', [multi, multi2, multi3])
async with await Config(od) as cfg:
owner = await cfg.owner.get()
assert await cfg.option('multi').value.get() == []
assert await cfg.option('multi3').owner.get() == owners.default
await cfg.option('multi').value.set([['no', 'yes'], ['peharps']])
assert await cfg.option('multi').owner.get() == owner
assert await cfg.option('multi').value.get() == [['no', 'yes'], ['peharps']]
od1 = OptionDescription('od', '', [multi, multi2, multi3])
cfg = Config(od1)
owner = cfg.owner.get()
assert cfg.option('multi').value.get() == []
assert cfg.option('multi3').owner.get() == owners.default
cfg.option('multi').value.set([['no', 'yes'], ['peharps']])
assert cfg.option('multi').owner.get() == owner
assert cfg.option('multi').value.get() == [['no', 'yes'], ['peharps']]
#
assert await cfg.option('multi3').value.get() == [['yes']]
assert await cfg.option('multi3').owner.get() == owners.default
await cfg.option('multi3').value.set([])
assert await cfg.option('multi').owner.get() == owner
assert await cfg.option('multi3').value.get() == []
await cfg.option('multi3').value.reset()
assert await cfg.option('multi3').owner.get() == owners.default
await cfg.option('multi3').value.set([[]])
assert await cfg.option('multi3').owner.get() == owner
assert await cfg.option('multi3').value.get() == [[]]
assert not await list_sessions()
assert cfg.option('multi3').value.get() == [['yes']]
assert cfg.option('multi3').owner.get() == owners.default
cfg.option('multi3').value.set([])
assert cfg.option('multi').owner.get() == owner
assert cfg.option('multi3').value.get() == []
cfg.option('multi3').value.reset()
assert cfg.option('multi3').owner.get() == owners.default
cfg.option('multi3').value.set([[]])
assert cfg.option('multi3').owner.get() == owner
assert cfg.option('multi3').value.get() == [[]]
# assert not list_sessions()
@pytest.mark.asyncio
async def test_callback_submulti_str():
def test_callback_submulti_str():
multi = StrOption('multi', '', [[Calculation(return_val)]], multi=submulti, default_multi=[Calculation(return_val)])
od = OptionDescription('od', '', [multi])
async with await Config(od) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
assert await cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi').value.get() == [['val']]
await cfg.option('multi').value.set([['val'], undefined])
assert await cfg.option('multi').owner.get() == owner
assert await cfg.option('multi').value.get() == [['val'], ['val']]
await cfg.option('multi').value.reset()
assert await cfg.option('multi').owner.get() == owners.default
assert not await list_sessions()
od1 = OptionDescription('od', '', [multi])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
assert cfg.option('multi').owner.get() == owners.default
assert cfg.option('multi').value.get() == [['val']]
cfg.option('multi').value.set([['val'], undefined])
assert cfg.option('multi').owner.get() == owner
assert cfg.option('multi').value.get() == [['val'], ['val']]
cfg.option('multi').value.reset()
assert cfg.option('multi').owner.get() == owners.default
# assert not list_sessions()
@pytest.mark.asyncio
async def test_callback_submulti_list():
def test_callback_submulti_list():
multi = StrOption('multi', '', [Calculation(return_list)], multi=submulti, default_multi=Calculation(return_list), properties=('notunique',))
od = OptionDescription('od', '', [multi])
async with await Config(od) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
assert await cfg.option('multi').value.get() == [['val', 'val']]
assert await cfg.option('multi').owner.get() == owners.default
await cfg.option('multi').value.set([['val', 'val'], undefined])
#assert await cfg.option('multi').owner.get() == owner
#assert await cfg.option('multi').value.get() == [['val', 'val'], ['val', 'val']]
#await cfg.option('multi').value.set([['val', 'val'], undefined, undefined])
#assert await cfg.option('multi').value.get() == [['val', 'val'], ['val', 'val'], ['val', 'val']]
#await cfg.option('multi').value.reset()
#assert await cfg.option('multi').owner.get() == owners.default
assert not await list_sessions()
od1 = OptionDescription('od', '', [multi])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
assert cfg.option('multi').value.get() == [['val', 'val']]
assert cfg.option('multi').owner.get() == owners.default
cfg.option('multi').value.set([['val', 'val'], undefined])
#assert cfg.option('multi').owner.get() == owner
#assert cfg.option('multi').value.get() == [['val', 'val'], ['val', 'val']]
#cfg.option('multi').value.set([['val', 'val'], undefined, undefined])
#assert cfg.option('multi').value.get() == [['val', 'val'], ['val', 'val'], ['val', 'val']]
#cfg.option('multi').value.reset()
#assert cfg.option('multi').owner.get() == owners.default
# assert not list_sessions()
@pytest.mark.asyncio
async def test_callback_submulti_list_list():
def test_callback_submulti_list_list():
multi = StrOption('multi', '', Calculation(return_list2), multi=submulti, properties=('notunique',))
od = OptionDescription('od', '', [multi])
async with await Config(od) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
assert await cfg.option('multi').value.get() == [['val', 'val']]
assert await cfg.option('multi').owner.get() == owners.default
await cfg.option('multi').value.set([['val', 'val'], undefined])
assert await cfg.option('multi').owner.get() == owner
assert await cfg.option('multi').value.get() == [['val', 'val'], []]
await cfg.option('multi').value.reset()
assert await cfg.option('multi').owner.get() == owners.default
assert not await list_sessions()
od1 = OptionDescription('od', '', [multi])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
assert cfg.option('multi').value.get() == [['val', 'val']]
assert cfg.option('multi').owner.get() == owners.default
cfg.option('multi').value.set([['val', 'val'], undefined])
assert cfg.option('multi').owner.get() == owner
assert cfg.option('multi').value.get() == [['val', 'val'], []]
cfg.option('multi').value.reset()
assert cfg.option('multi').owner.get() == owners.default
# assert not list_sessions()
@pytest.mark.asyncio
async def test_groups_with_leader_submulti():
def test_groups_with_leader_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
assert interface1.impl_get_group_type() == groups.leadership
@pytest.mark.asyncio
async def test_groups_with_leader_in_config_submulti():
def test_groups_with_leader_in_config_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
od = OptionDescription('root', '', [interface1])
async with await Config(od) as cfg:
pass
od1 = OptionDescription('root', '', [interface1])
cfg = Config(od1)
assert interface1.impl_get_group_type() == groups.leadership
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_values_with_leader_and_followers_submulti():
def test_values_with_leader_and_followers_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
od1 = OptionDescription('toto', '', [interface1])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
assert interface1.impl_get_group_type() == groups.leadership
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145"])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ["192.168.230.145"]
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == []
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owners.default
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145", "192.168.230.147"])
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == []
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == []
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == []
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145"])
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ["192.168.230.145"]
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == []
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owners.default
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145", "192.168.230.147"])
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == []
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == []
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == []
with pytest.raises(ValueError):
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('255.255.255.0')
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('255.255.255.0')
with pytest.raises(ValueError):
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set([['255.255.255.0']])
assert not await list_sessions()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set([['255.255.255.0']])
# assert not list_sessions()
@pytest.mark.asyncio
async def test_values_with_leader_and_followers_submulti_default_multi():
def test_values_with_leader_and_followers_submulti_default_multi():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti, default_multi=['255.255.0.0', '0.0.0.0'])
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
od1 = OptionDescription('toto', '', [interface1])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
assert interface1.impl_get_group_type() == groups.leadership
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145"])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ["192.168.230.145"]
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.0.0', '0.0.0.0']
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145", "192.168.230.147"])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == ['255.255.0.0', '0.0.0.0']
assert not await list_sessions()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145"])
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ["192.168.230.145"]
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.0.0', '0.0.0.0']
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145", "192.168.230.147"])
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == ['255.255.0.0', '0.0.0.0']
# assert not list_sessions()
@pytest.mark.asyncio
async def test_reset_values_with_leader_and_followers_submulti():
def test_reset_values_with_leader_and_followers_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
od1 = OptionDescription('toto', '', [interface1])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
assert interface1.impl_get_group_type() == groups.leadership
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owners.default
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owners.default
cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
#
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owner
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
assert not await list_sessions()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owner
cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
# assert not list_sessions()
@pytest.mark.asyncio
async def test_values_with_leader_and_followers_follower_submulti():
def test_values_with_leader_and_followers_follower_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, properties=('notunique',))
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg:
await cfg.property.read_write()
od1 = OptionDescription('toto', '', [interface1])
cfg = Config(od1)
cfg.property.read_write()
with pytest.raises(LeadershipError):
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0', '255.255.255.0'])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.reset()
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145', '192.168.230.145'])
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == []
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
assert not await list_sessions()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0', '255.255.255.0'])
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.reset()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145', '192.168.230.145'])
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == []
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
# assert not list_sessions()
@pytest.mark.asyncio
async def test_values_with_leader_and_leadership_submulti():
def test_values_with_leader_and_leadership_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, properties=('notunique',))
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg:
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145"])
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145", "192.168.230.145"])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set(['255.255.255.0'])
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == ['255.255.255.0']
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(1)
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ["192.168.230.145"]
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
assert not await list_sessions()
od1 = OptionDescription('toto', '', [interface1])
cfg = Config(od1)
cfg.property.read_write()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145"])
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(["192.168.230.145", "192.168.230.145"])
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['255.255.255.0'])
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set(['255.255.255.0'])
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == ['255.255.255.0']
cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(1)
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ["192.168.230.145"]
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == ['255.255.255.0']
cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
# assert not list_sessions()
@pytest.mark.asyncio
async def test_values_with_leader_owner_submulti():
def test_values_with_leader_owner_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owners.default
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
assert not await list_sessions()
od1 = OptionDescription('toto', '', [interface1])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owners.default
cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
# assert not list_sessions()
@pytest.mark.asyncio
async def test_values_with_leader_disabled_submulti():
def test_values_with_leader_disabled_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, properties=('notunique',))
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=submulti)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg:
await cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['192.168.230.145'])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.reset()
await cfg.option('ip_admin_eth0.netmask_admin_eth0').property.add('disabled')
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145', '192.168.230.145'])
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(1)
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
od1 = OptionDescription('toto', '', [interface1])
cfg = Config(od1)
cfg.property.read_write()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['192.168.230.145'])
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.reset()
cfg.option('ip_admin_eth0.netmask_admin_eth0').property.add('disabled')
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145', '192.168.230.145'])
cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(1)
cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
#delete with value in disabled var
await cfg.unrestraint.option('ip_admin_eth0.netmask_admin_eth0').property.pop('disabled')
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['192.168.230.145'])
await cfg.unrestraint.option('ip_admin_eth0.netmask_admin_eth0').property.add('disabled')
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
assert not await list_sessions()
cfg.unrestraint.option('ip_admin_eth0.netmask_admin_eth0').property.remove('disabled')
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.230.145'])
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set(['192.168.230.145'])
cfg.unrestraint.option('ip_admin_eth0.netmask_admin_eth0').property.add('disabled')
cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_leader_is_submulti():
def test_leader_is_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=submulti)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
od1 = OptionDescription('toto', '', [interface1])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
assert interface1.impl_get_group_type() == groups.leadership
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.isdefault()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([["192.168.230.145"]])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [["192.168.230.145"]]
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.isdefault()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([["192.168.230.145"], ["192.168.230.147"]])
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == None
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([["192.168.230.145", '192.168.1.1'], ["192.168.230.147"]])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [["192.168.230.145", '192.168.1.1'], ["192.168.230.147"]]
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.isdefault()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([["192.168.230.145"]])
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [["192.168.230.145"]]
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.isdefault()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([["192.168.230.145"], ["192.168.230.147"]])
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
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([["192.168.230.145", '192.168.1.1'], ["192.168.230.147"]])
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [["192.168.230.145", '192.168.1.1'], ["192.168.230.147"]]
with pytest.raises(ValueError):
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.1', '192.168.1.1'])
assert not await list_sessions()
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.1', '192.168.1.1'])
# assert not list_sessions()
@pytest.mark.asyncio
async def test_callback_submulti():
def test_callback_submulti():
multi = StrOption('multi', '', multi=submulti)
multi2 = StrOption('multi2', '', Calculation(return_val, Params(ParamOption(multi))), multi=submulti)
od = OptionDescription('multi', '', [multi, multi2])
async with await Config(od) as cfg:
await cfg.property.read_write()
owner = await cfg.owner.get()
assert await cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi').value.get() == []
assert await cfg.option('multi2').value.get() == []
await cfg.option('multi').value.set([['val']])
assert await cfg.option('multi').owner.get() == owner
assert await cfg.option('multi2').owner.get() == owners.default
assert await cfg.option('multi').value.get() == [['val']]
assert await cfg.option('multi2').value.get() == [['val']]
assert not await list_sessions()
od1 = OptionDescription('multi', '', [multi, multi2])
cfg = Config(od1)
cfg.property.read_write()
owner = cfg.owner.get()
assert cfg.option('multi').owner.get() == owners.default
assert cfg.option('multi').value.get() == []
assert cfg.option('multi2').value.get() == []
cfg.option('multi').value.set([['val']])
assert cfg.option('multi').owner.get() == owner
assert cfg.option('multi2').owner.get() == owners.default
assert cfg.option('multi').value.get() == [['val']]
assert cfg.option('multi2').value.get() == [['val']]
# assert not list_sessions()
@pytest.mark.asyncio
async def test_callback_submulti_follower():
def test_callback_submulti_follower():
multi = StrOption('multi', '', multi=True)
multi2 = StrOption('multi2', '', Calculation(return_list), multi=submulti)
od = Leadership('multi', '', [multi, multi2])
od = OptionDescription('multi', '', [od])
async with await Config(od) as cfg:
await cfg.property.read_write()
assert await cfg.option('multi.multi').value.get() == []
await cfg.option('multi.multi').value.set(['val'])
assert await cfg.option('multi.multi2', 0).value.get() == ['val', 'val']
assert not await list_sessions()
od1 = OptionDescription('multi', '', [od])
cfg = Config(od1)
cfg.property.read_write()
assert cfg.option('multi.multi').value.get() == []
cfg.option('multi.multi').value.set(['val'])
assert cfg.option('multi.multi2', 0).value.get() == ['val', 'val']
# assert not list_sessions()
@pytest.mark.asyncio
async def test_submulti_unique():
def test_submulti_unique():
i = IntOption('int', '', multi=submulti, properties=('unique',))
o = OptionDescription('od', '', [i])
async with await Config(o) as cfg:
assert await cfg.option('int').value.get() == []
await cfg.option('int').value.set([[0]])
assert await cfg.option('int').value.get() == [[0]]
od1 = OptionDescription('od', '', [i])
cfg = Config(od1)
assert cfg.option('int').value.get() == []
cfg.option('int').value.set([[0]])
assert cfg.option('int').value.get() == [[0]]
with pytest.raises(ValueError):
await cfg.option('int').value.set([[0, 0]])
await cfg.option('int').value.set([[0], [0]])
cfg.option('int').value.set([[0, 0]])
cfg.option('int').value.set([[0], [0]])
with pytest.raises(ValueError):
await cfg.option('int').value.set([[1, 0, 2, 3, 4, 5, 6, 0, 7], [0]])
await cfg.option('int').value.set([[0, 4, 5, 6], [0]])
assert not await list_sessions()
cfg.option('int').value.set([[1, 0, 2, 3, 4, 5, 6, 0, 7], [0]])
cfg.option('int').value.set([[0, 4, 5, 6], [0]])
# assert not list_sessions()
@pytest.mark.asyncio
async def test_multi_submulti_meta():
def test_multi_submulti_meta():
multi = StrOption('multi', '', multi=submulti)
od = OptionDescription('od', '', [multi])
async with await Config(od, session_id='cfg') as cfg:
await cfg.property.read_write()
async with await Config(od, session_id='cfg2') as cfg2:
await cfg2.property.read_write()
async with await MetaConfig([cfg, cfg2]) as meta:
await meta.property.read_write()
await meta.option('multi').value.set([['val']])
assert await meta.option('multi').value.get() == [['val']]
newcfg = await meta.config('cfg')
await newcfg.option('multi').value.set([['val', None]])
assert await cfg.option('multi').value.get() == [['val', None]]
newcfg = await meta.config('cfg')
assert await newcfg.option('multi').value.get() == [['val', None]]
assert await meta.option('multi').value.get() == [['val']]
assert not await list_sessions()
od1 = OptionDescription('od', '', [multi])
cfg = Config(od1, name='cfg')
cfg.property.read_write()
cfg2 = Config(od1)
cfg2.property.read_write()
meta = MetaConfig([cfg, cfg2])
meta.property.read_write()
meta.option('multi').value.set([['val']])
assert meta.option('multi').value.get() == [['val']]
newcfg = meta.config('cfg')
newcfg.option('multi').value.set([['val', None]])
assert cfg.option('multi').value.get() == [['val', None]]
newcfg = meta.config('cfg')
assert newcfg.option('multi').value.get() == [['val', None]]
assert meta.option('multi').value.get() == [['val']]
# assert not list_sessions()
@pytest.mark.asyncio
async def test_multi_submulti_meta_no_cache():
def test_multi_submulti_meta_no_cache():
multi = StrOption('multi', '', multi=submulti)
multi = StrOption('multi', '', multi=submulti)
od = OptionDescription('od', '', [multi])
async with await Config(od, session_id='cfg') as cfg:
await cfg.property.read_write()
async with await Config(od, session_id='cfg2') as cfg2:
await cfg.property.read_write()
async with await MetaConfig([cfg, cfg2]) as meta:
await meta.property.read_write()
await meta.property.pop('cache')
await meta.option('multi').value.set([['val']])
assert await meta.option('multi').value.get() == [['val']]
newcfg = await meta.config('cfg')
await newcfg.option('multi').value.set([['val', None]])
assert await cfg.option('multi').value.get() == [['val', None]]
newcfg = await meta.config('cfg')
assert await newcfg.option('multi').value.get() == [['val', None]]
assert await meta.option('multi').value.get() == [['val']]
assert not await list_sessions()
od1 = OptionDescription('od', '', [multi])
cfg = Config(od1, name='cfg')
cfg.property.read_write()
cfg2 = Config(od1)
cfg.property.read_write()
meta = MetaConfig([cfg, cfg2])
meta.property.read_write()
meta.property.remove('cache')
meta.option('multi').value.set([['val']])
assert meta.option('multi').value.get() == [['val']]
newcfg = meta.config('cfg')
newcfg.option('multi').value.set([['val', None]])
assert cfg.option('multi').value.get() == [['val', None]]
newcfg = meta.config('cfg')
assert newcfg.option('multi').value.get() == [['val', None]]
assert meta.option('multi').value.get() == [['val']]
# assert not list_sessions()

369
tests/test_symlink.py
View file

@ -6,10 +6,8 @@ from .config import config_type, get_config
from tiramisu import BoolOption, StrOption, SymLinkOption, \
OptionDescription, Leadership, Config, Calculation, calc_value, Params, ParamOption, ParamValue
from tiramisu.error import PropertiesOptionError, ConfigError
from tiramisu.error import PropertiesOptionError, ConfigError, APIError
from tiramisu.setting import groups, owners
from tiramisu.storage import list_sessions
from .config import event_loop
def return_value():
@ -17,129 +15,120 @@ def return_value():
#____________________________________________________________
@pytest.mark.asyncio
async def test_symlink_option(config_type):
def test_symlink_option(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "",
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('s1.b').value.get() is False
await cfg.option("s1.b").value.set(True)
await cfg.option("s1.b").value.set(False)
assert await cfg.option('s1.b').value.get() is False
assert await cfg.option('c').value.get() is False
await cfg.option('s1.b').value.set(True)
assert await cfg.option('s1.b').value.get() is True
assert await cfg.option('c').value.get() is True
await cfg.option('s1.b').value.set(False)
assert await cfg.option('s1.b').value.get() is False
assert await cfg.option('c').value.get() is False
assert not await list_sessions()
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('s1.b').value.get() is False
cfg.option("s1.b").value.set(True)
cfg.option("s1.b").value.set(False)
assert cfg.option('s1.b').value.get() is False
assert cfg.option('c').value.get() is False
cfg.option('s1.b').value.set(True)
assert cfg.option('s1.b').value.get() is True
assert cfg.option('c').value.get() is True
cfg.option('s1.b').value.set(False)
assert cfg.option('s1.b').value.get() is False
assert cfg.option('c').value.get() is False
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_assign_option(config_type):
def test_symlink_assign_option(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "",
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
cfg = Config(od1)
cfg = get_config(cfg, config_type)
with pytest.raises(ConfigError):
await cfg.option('c').value.set(True)
assert not await list_sessions()
cfg.option('c').value.set(True)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_del_option(config_type):
def test_symlink_del_option(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "",
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
cfg = Config(od1)
cfg = get_config(cfg, config_type)
with pytest.raises(ConfigError):
await cfg.option('c').value.reset()
assert not await list_sessions()
cfg.option('c').value.reset()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_addproperties():
def test_symlink_addproperties():
boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
od1 = OptionDescription('opt', '', [boolopt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
with pytest.raises(TypeError):
await cfg.option('c').property.add('new')
cfg.option('c').property.add('new')
try:
await cfg.option('c').property.reset()
cfg.option('c').property.reset()
except AssertionError:
pass
else:
raise Exception('must raise')
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_getpermissive():
def test_symlink_getpermissive():
boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.option('b').permissive.set(frozenset(['perm']))
await cfg.option('c').permissive.get() == frozenset(['perm'])
assert not await list_sessions()
od1 = OptionDescription('opt', '', [boolopt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
cfg.option('b').permissive.set(frozenset(['perm']))
cfg.option('c').permissive.get() == frozenset(['perm'])
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_addpermissives():
def test_symlink_addpermissives():
boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
od1 = OptionDescription('opt', '', [boolopt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
with pytest.raises(TypeError):
await cfg.option('c').permissive.set(frozenset(['new']))
cfg.option('c').permissive.set(frozenset(['new']))
try:
await cfg.option('c').permissive.reset()
cfg.option('c').permissive.reset()
except AssertionError:
pass
else:
raise Exception('must raise')
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_getproperties():
def test_symlink_getproperties():
boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
od1 = OptionDescription('opt', '', [boolopt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
assert boolopt.impl_getproperties() == linkopt.impl_getproperties() == {'test'}
assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False
assert not await list_sessions()
# assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_getcallback():
def test_symlink_getcallback():
boolopt = BoolOption('b', '', Calculation(return_value))
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
od1 = OptionDescription('opt', '', [boolopt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
#assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == True
#assert boolopt.impl_get_callback() == linkopt.impl_get_callback() == (return_value, None)
assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False
assert not await list_sessions()
# assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_requires(config_type):
def test_symlink_requires(config_type):
boolopt = BoolOption('b', '', default=True)
disabled_property = Calculation(calc_value,
Params(ParamValue('disabled'),
@ -147,86 +136,82 @@ async def test_symlink_requires(config_type):
'expected': ParamValue(False)}))
stropt = StrOption('s', '', properties=(disabled_property,))
linkopt = SymLinkOption("c", stropt)
descr = OptionDescription('opt', '', [boolopt, stropt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
assert await cfg.option('b').value.get() is True
assert await cfg.option('s').value.get() is None
assert await cfg.option('c').value.get() is None
await cfg.option('b').value.set(False)
od1 = OptionDescription('opt', '', [boolopt, stropt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
assert cfg.option('b').value.get() is True
assert cfg.option('s').value.get() is None
assert cfg.option('c').value.get() is None
cfg.option('b').value.set(False)
#
props = []
try:
await cfg.option('s').value.get()
cfg.option('s').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert props == {'disabled'}
#
props = []
try:
await cfg.option('c').value.get()
cfg.option('c').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert props == {'disabled'}
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_multi(config_type):
def test_symlink_multi(config_type):
boolopt = BoolOption("b", "", default=[False], multi=True)
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "",
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('s1.b').value.get() == [False]
assert await cfg.option('c').value.get() == [False]
await cfg.option('s1.b').value.set([True])
assert await cfg.option('s1.b').value.get() == [True]
assert await cfg.option('c').value.get() == [True]
await cfg.option('s1.b').value.set([False])
assert await cfg.option('s1.b').value.get() == [False]
assert await cfg.option('c').value.get() == [False]
await cfg.option('s1.b').value.set([False, True])
assert await cfg.option('s1.b').value.get() == [False, True]
assert await cfg.option('c').value.get() == [False, True]
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('s1.b').value.get() == [False]
assert cfg.option('c').value.get() == [False]
cfg.option('s1.b').value.set([True])
assert cfg.option('s1.b').value.get() == [True]
assert cfg.option('c').value.get() == [True]
cfg.option('s1.b').value.set([False])
assert cfg.option('s1.b').value.get() == [False]
assert cfg.option('c').value.get() == [False]
cfg.option('s1.b').value.set([False, True])
assert cfg.option('s1.b').value.get() == [False, True]
assert cfg.option('c').value.get() == [False, True]
assert boolopt.impl_is_multi() is True
assert linkopt.impl_is_multi() is True
assert not await list_sessions()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_assign(config_type):
def test_symlink_assign(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "",
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
cfg = Config(od1)
cfg = get_config(cfg, config_type)
with pytest.raises(ConfigError):
await cfg.option('c').value.set(True)
assert not await list_sessions()
cfg.option('c').value.set(True)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_owner(config_type):
def test_symlink_owner(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "",
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('s1.b').owner.isdefault()
assert await cfg.option('c').owner.isdefault()
await cfg.option('s1.b').value.set(True)
assert not await cfg.option('s1.b').owner.isdefault()
assert not await cfg.option('c').owner.isdefault()
assert not await list_sessions()
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('s1.b').owner.isdefault()
assert cfg.option('c').owner.isdefault()
cfg.option('s1.b').value.set(True)
assert not cfg.option('s1.b').owner.isdefault()
assert not cfg.option('c').owner.isdefault()
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_get_information():
def test_symlink_get_information():
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
boolopt.impl_set_information('test', 'test')
@ -237,8 +222,7 @@ async def test_symlink_get_information():
assert linkopt.impl_get_information('test') == 'test2'
@pytest.mark.asyncio
async def test_symlink_leader():
def test_symlink_leader():
a = StrOption('a', "", multi=True)
ip_admin_eth0 = SymLinkOption('ip_admin_eth0', a)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "", multi=True)
@ -246,8 +230,7 @@ async def test_symlink_leader():
Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
@pytest.mark.asyncio
async def test_symlink_followers():
def test_symlink_followers():
a = StrOption('a', "", multi=True)
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = SymLinkOption('netmask_admin_eth0', a)
@ -255,107 +238,105 @@ async def test_symlink_followers():
Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
@pytest.mark.asyncio
async def test_symlink_with_leader(config_type):
def test_symlink_with_leader(config_type):
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
leader = SymLinkOption('leader', ip_admin_eth0)
od = OptionDescription('root', '', [interface1, leader])
async with await Config(od) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'leader': []}
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'leader': ['val1', 'val2']}
assert not await list_sessions()
od1 = OptionDescription('root', '', [interface1, leader])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
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': ['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)
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_with_follower(config_type):
def test_symlink_with_follower(config_type):
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
follower = SymLinkOption('follower', netmask_admin_eth0)
od = OptionDescription('root', '', [interface1, follower])
async with await Config(od) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'follower': []}
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'follower': [None, None]}
od1 = OptionDescription('root', '', [interface1, follower])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
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': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'follower': [None, None]}
#
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == 'default'
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).owner.get() == 'default'
assert await cfg.option('follower', 0).owner.get() == 'default'
assert await cfg.option('follower', 1).owner.get() == 'default'
assert await cfg.option('follower').owner.get() == ['default', 'default']
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'
assert cfg.option('follower', 0).owner.get() == 'default'
assert cfg.option('follower', 1).owner.get() == 'default'
assert cfg.option('follower').owner.get() == ['default', 'default']
#
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == None
assert await cfg.option('follower', 0).value.get() == None
assert await cfg.option('follower', 1).value.get() == None
assert await cfg.option('follower').value.get() == [None, None]
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
assert cfg.option('follower', 0).value.get() == None
assert cfg.option('follower', 1).value.get() == None
assert cfg.option('follower').value.get() == [None, None]
#
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('val3')
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, 'val3'], 'follower': [None, 'val3']}
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('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 await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == 'val3'
assert await cfg.option('follower', 0).value.get() == None
assert await cfg.option('follower', 1).value.get() == 'val3'
assert await cfg.option('follower').value.get() == [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'
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 await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == 'default'
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).owner.get() == 'user'
assert await cfg.option('follower', 0).owner.get() == 'default'
assert await cfg.option('follower', 1).owner.get() == 'user'
assert await cfg.option('follower').owner.get() == ['default', 'user']
assert not await list_sessions()
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'
assert cfg.option('follower', 0).owner.get() == 'default'
assert cfg.option('follower', 1).owner.get() == 'user'
assert cfg.option('follower').owner.get() == ['default', 'user']
# assert not list_sessions()
#____________________________________________________________
@pytest.mark.asyncio
async def test_symlink_dependency():
def test_symlink_dependency():
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "",
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg:
assert await cfg.option('s1.b').option.has_dependency() is False
assert await cfg.option('c').option.has_dependency() is True
assert await cfg.option('s1.b').option.has_dependency(False) is True
assert await cfg.option('c').option.has_dependency(False) is False
assert not await list_sessions()
cfg = Config(od1)
assert cfg.option('s1.b').option.has_dependency() is False
assert cfg.option('c').option.has_dependency() is True
assert cfg.option('s1.b').option.has_dependency(False) is True
assert cfg.option('c').option.has_dependency(False) is False
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_makedict(config_type):
def test_symlink_makedict(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "",
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.value.dict() == {'c': False, 's1.b': False}
await cfg.option('s1.b').value.set(True)
assert await cfg.value.dict() == {'c': True, 's1.b': True}
assert not await list_sessions()
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.value.dict() == {'c': False, 's1.b': False}
cfg.option('s1.b').value.set(True)
assert cfg.value.dict() == {'c': True, 's1.b': True}
# assert not list_sessions()
@pytest.mark.asyncio
async def test_symlink_list(config_type):
def test_symlink_list(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "",
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
cfg = Config(od1)
cfg = get_config(cfg, config_type)
list_opt = []
for opt in await cfg.option.list():
list_opt.append(await opt.option.path())
for opt in cfg.option.list():
list_opt.append(opt.option.path())
assert list_opt == ['c']
#
list_opt = []
for opt in await cfg.option.list(recursive=True):
list_opt.append(await opt.option.path())
for opt in cfg.option.list(recursive=True):
list_opt.append(opt.option.path())
assert list_opt == ['c', 's1.b']
assert not await list_sessions()
# assert not list_sessions()

6
tiramisu/__init__.py
View file

@ -24,8 +24,6 @@ from .error import APIError
from .api import Config, MetaConfig, GroupConfig, MixConfig
from .option import __all__ as all_options
from .setting import owners, groups, undefined
from .storage import default_storage, Storage, list_sessions, \
delete_session
allfuncs = ['Calculation',
@ -46,10 +44,6 @@ allfuncs = ['Calculation',
'undefined',
'owners',
'groups',
'default_storage',
'Storage',
'list_sessions',
'delete_session',
'calc_value',
'calc_value_property_help',
'valid_ip_netmask',

1316
tiramisu/api.py
View file

File diff suppressed because it is too large Load diff

29
tiramisu/asyncinit.py
View file

@ -1,29 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright (C) 2019-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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/>.
#
# largely inspired by https://github.com/kchmck/pyasyncinit
# ____________________________________________________________
from functools import wraps
def asyncinit(obj):
@wraps(obj.__new__)
async def new(cls, *args, **kwargs):
instance = object.__new__(cls) # (cls, *args, **kwargs)
await instance.__init__(*args, **kwargs)
return instance
obj.__new__ = new
return obj

83
tiramisu/autolib.py
View file

@ -19,7 +19,6 @@
# ____________________________________________________________
"enables us to carry out a calculation and return an option's value"
from typing import Any, Optional, Union, Callable, Dict, List
from types import CoroutineType
from itertools import chain
from .error import PropertiesOptionError, ConfigError, LeadershipError, ValueWarning
@ -168,7 +167,7 @@ class Calculation:
if warnings_only is True:
self.warnings_only = warnings_only
async def execute(self,
def execute(self,
option_bag: OptionBag,
leadership_must_have_index: bool=False,
orig_value: Any=undefined,
@ -176,7 +175,7 @@ class Calculation:
force_value_warning: bool=False,
for_settings: bool=False,
) -> Any:
return await carry_out_calculation(option_bag.option,
return carry_out_calculation(option_bag.option,
callback=self.function,
callback_params=self.params,
index=option_bag.index,
@ -188,17 +187,17 @@ class Calculation:
for_settings=for_settings,
)
async def help(self,
def help(self,
option_bag: OptionBag,
leadership_must_have_index: bool=False,
for_settings: bool=False,
) -> str:
if not self.help_function:
return await self.execute(option_bag,
return self.execute(option_bag,
leadership_must_have_index=leadership_must_have_index,
for_settings=for_settings,
)
return await carry_out_calculation(option_bag.option,
return carry_out_calculation(option_bag.option,
callback=self.help_function,
callback_params=self.params,
index=option_bag.index,
@ -223,7 +222,7 @@ class Break(Exception):
pass
async def manager_callback(callbk: Param,
def manager_callback(callbk: Param,
option,
index: Optional[int],
orig_value,
@ -244,7 +243,7 @@ async def manager_callback(callbk: Param,
return index
return None
async 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)
@ -252,11 +251,12 @@ async def manager_callback(callbk: Param,
if config_bag is undefined:
return undefined
path = option.impl_getpath()
option_bag = await get_option_bag(config_bag,
option_bag = get_option_bag(config_bag,
option,
apply_index,
True)
new_value = await 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
@ -264,14 +264,15 @@ async def manager_callback(callbk: Param,
value = value[apply_index]
return value
async def get_value(callbk,
def get_value(callbk,
option_bag,
path,
):
try:
# get value
value = await config_bag.context.getattr(path,
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:
@ -285,12 +286,12 @@ async def manager_callback(callbk: Param,
# cannot acces, simulate a propertyerror
raise PropertiesOptionError(option_bag,
['configerror'],
config_bag.context.cfgimpl_get_settings(),
config_bag.context.get_settings(),
)
raise ConfigError(_(f'unable to get value for calculating "{option_bag.option.impl_get_display_name()}", {err}')) from err
return value
async def get_option_bag(config_bag,
def get_option_bag(config_bag,
opt,
index_,
self_calc):
@ -301,18 +302,14 @@ async def manager_callback(callbk: Param,
config_bag.set_permissive()
if not for_settings:
config_bag.properties -= {'warnings'}
option_bag = OptionBag()
option_bag.set_option(opt,
if self_calc:
config_bag.unrestraint()
config_bag.remove_validation()
option_bag = OptionBag(opt,
index_,
config_bag)
if not self_calc:
option_bag.properties = await config_bag.context.cfgimpl_get_settings().getproperties(option_bag)
else:
option_bag.config_bag.unrestraint()
option_bag.config_bag.remove_validation()
# if we are in properties calculation, cannot calculated properties
option_bag.properties = await config_bag.context.cfgimpl_get_settings().getproperties(option_bag,
apply_requires=False)
config_bag,
apply_requires=not self_calc, # if we are in properties calculation, cannot calculated properties
)
return option_bag
if isinstance(callbk, ParamValue):
@ -320,15 +317,14 @@ async def manager_callback(callbk: Param,
if isinstance(callbk, ParamInformation):
if isinstance(callbk, ParamSelfInformation):
option_bag = OptionBag()
option_bag.set_option(option,
option_bag = OptionBag(option,
index,
config_bag,
)
else:
option_bag = None
try:
return await config_bag.context.impl_get_information(config_bag,
return config_bag.context.impl_get_information(config_bag,
option_bag,
callbk.information_name,
callbk.default_value,
@ -349,7 +345,7 @@ async 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 = await 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(),
@ -387,7 +383,7 @@ async def manager_callback(callbk: Param,
dynopt = callbk_option.getsubdyn()
rootpath = dynopt.impl_getpath()
subpaths = [rootpath] + callbk_option.impl_getpath()[len(rootpath) + 1:].split('.')[:-1]
for suffix in await dynopt.get_suffixes(config_bag):
for suffix in dynopt.get_suffixes(config_bag):
path_suffix = dynopt.convert_suffix_to_path(suffix)
subpath = '.'.join([subp + path_suffix for subp in subpaths])
doption = callbk_option.to_dynoption(subpath,
@ -418,11 +414,12 @@ async def manager_callback(callbk: Param,
index_ = None
with_index = False
path = callbk_option.impl_getpath()
option_bag = await get_option_bag(config_bag,
option_bag = get_option_bag(config_bag,
callbk_option,
index_,
False)
value = await get_value(callbk,
False,
)
value = get_value(callbk,
option_bag,
path,
)
@ -440,7 +437,7 @@ async def manager_callback(callbk: Param,
option.impl_get_display_name()))
async def carry_out_calculation(option,
def carry_out_calculation(option,
callback: Callable,
callback_params: Optional[Params],
index: Optional[int],
@ -474,7 +471,7 @@ async def carry_out_calculation(option,
if callback_params:
for key, callbk in chain(fake_items(callback_params.args), callback_params.kwargs.items()):
try:
value = await manager_callback(callbk,
value = manager_callback(callbk,
option,
index,
orig_value,
@ -498,12 +495,13 @@ async def carry_out_calculation(option,
kwargs[key] = {'propertyerror': str(err)}
except Break:
continue
ret = await calculate(option,
ret = calculate(option,
callback,
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:
@ -524,7 +522,7 @@ async def carry_out_calculation(option,
return ret
async def calculate(option,
def calculate(option,
callback: Callable,
allow_value_error: bool,
force_value_warning: bool,
@ -539,10 +537,7 @@ async def calculate(option,
"""
try:
ret = callback(*args, **kwargs)
if isinstance(ret, CoroutineType):
ret = await ret
return ret
return callback(*args, **kwargs)
except (ValueError, ValueWarning) as err:
if allow_value_error:
if force_value_warning:

53
tiramisu/storage/cacheobj.py → tiramisu/cacheobj.py
View file

@ -16,25 +16,35 @@
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# ____________________________________________________________
from time import time
from .cache.dictionary import Cache as DictCache
from ..log import log
from .log import log
def _display_classname(obj): # pragma: no cover
return(obj.__class__.__name__.lower())
class Cache(DictCache):
class Cache:
__slots__ = ('_cache',)
def __init__(self):
self._cache = {}
def setcache(self, path, index, val, self_props, props, validated):
"""add val in cache for a specified path
if follower, add index
"""
if 'cache' in props or 'cache' in self_props:
# log.debug('setcache %s with index %s and value %s in %s (%s)',
# path, index, val, _display_classname(self), id(self))
super().setcache(path, index, val, time(), validated)
# log.debug('not setcache %s with index %s and value %s and props %s and %s in %s (%s)',
# path, index, val, props, self_props, _display_classname(self), id(self))
self._cache.setdefault(path, {})[index] = (val, int(time()), validated)
def delcache(self, path):
if path in self._cache:
del self._cache[path]
def get_cached(self):
return self._cache
def reset_all_cache(self):
self._cache.clear()
def getcache(self,
path,
@ -45,7 +55,12 @@ class Cache(DictCache):
type_):
no_cache = False, None, False
if 'cache' in props or type_ == 'context_props':
indexed = super().getcache(path, index)
values = self._cache.get(path)
if values is None:
indexed = None
else:
indexed = values.get(index)
if indexed is None:
return no_cache
value, timestamp, validated = indexed
@ -76,23 +91,3 @@ class Cache(DictCache):
# log.debug('getcache %s with index %s not in %s cache',
# path, index, _display_classname(self))
return no_cache
def delcache(self, path):
"""remove cache for a specified path
"""
# log.debug('delcache %s %s %s', path, _display_classname(self), id(self))
super().delcache(path)
def reset_all_cache(self):
"empty the cache"
# log.debug('reset_all_cache %s %s', _display_classname(self), id(self))
super().reset_all_cache()
def get_cached(self):
"""return all values in a dictionary
please only use it in test purpose
example: {'path1': {'index1': ('value1', 'time1')}, 'path2': {'index2': ('value2', 'time2', )}}
"""
cache = super().get_cached()
# log.debug('get_chached %s for %s (%s)', cache, _display_classname(self), id(self))
return cache

1457
tiramisu/config.py
View file

File diff suppressed because it is too large Load diff

2
tiramisu/error.py
View file

@ -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 `_cfgimpl_descr` is None
or in case of `_descr` is None
or if a calculation cannot be carried out"""
def __init__(self,
exp,

10
tiramisu/i18n.py
View file

@ -37,10 +37,10 @@ def get_translation() -> str:
app_name = __name__[:-5]
translations_path = resource_filename(app_name, 'locale')
if 'TIRAMISU_LOCALE' in environ:
if 'TIRAMISU_LOCALE' in environ: # pragma: no cover
user_locale = environ['TIRAMISU_LOCALE']
else:
if 'Windows' in system():
if 'Windows' in system(): # pragma: no cover
import ctypes
from locale import windows_locale
default_locale = windows_locale[ctypes.windll.kernel32.GetUserDefaultUILanguage()]
@ -52,9 +52,9 @@ def get_translation() -> str:
user_locale = default_locale[0][:2]
else:
user_locale = DEFAULT
elif default_locale:
elif default_locale: # pragma: no cover
user_locale = default_locale[:2]
else:
else: # pragma: no cover
user_locale = DEFAULT
try:
trans = translation(domain=app_name,
@ -62,7 +62,7 @@ def get_translation() -> str:
languages=[user_locale],
)
# codeset='UTF-8')
except FileNotFoundError:
except FileNotFoundError: # pragma: no cover
log.debug('cannot found translation file for langage {} in localedir {}'.format(user_locale,
translations_path))
trans = NullTranslations()

2
tiramisu/log.py
View file

@ -20,7 +20,7 @@ import os
log = getLogger('tiramisu')
if os.environ.get('TIRAMISU_DEBUG') == 'True':
if os.environ.get('TIRAMISU_DEBUG') == 'True': # pragma: no cover
log.setLevel(DEBUG)
handler = StreamHandler()
handler.setLevel(DEBUG)

42
tiramisu/option/baseoption.py
View file

@ -126,29 +126,6 @@ class Base:
options.append(weakref.ref(option))
self._suffixes_dependencies = tuple(options)
def _impl_set_callback(self,
callback: Callable,
callback_params: Optional[Params]=None) -> None:
if __debug__:
if callback is None and callback_params is not None:
raise ValueError(_("params defined for a callback function but "
"no callback defined"
' yet for option "{0}"').format(
self.impl_getname()))
self._validate_calculator(callback,
callback_params)
if callback is not None:
callback_params = self._build_calculator_params(callback,
callback_params,
'callback')
# first part is validator
val = getattr(self, '_val_call', (None,))[0]
if not callback_params:
val_call = (callback,)
else:
val_call = (callback, callback_params)
self._val_call = (val, val_call)
def impl_is_optiondescription(self) -> bool:
return False
@ -180,8 +157,9 @@ class Base:
return getattr(self, '_properties', frozenset())
def _setsubdyn(self,
subdyn) -> None:
self._subdyn = weakref.ref(subdyn)
subdyn,
) -> None:
self._subdyn = subdyn
def issubdyn(self) -> bool:
return getattr(self, '_subdyn', None) is not None
@ -189,16 +167,6 @@ class Base:
def getsubdyn(self):
return self._subdyn()
def impl_get_callback(self):
call = getattr(self, '_val_call', (None, None))[1]
if call is None:
ret_call = (None, None)
elif len(call) == 1:
ret_call = (call[0], None)
else:
ret_call = call
return ret_call
# ____________________________________________________________
# information
def impl_get_information(self,
@ -287,6 +255,8 @@ class BaseOption(Base):
def impl_has_callback(self) -> bool:
"to know if a callback has been defined or not"
if self.impl_get_callback()[0] is not None:
print('ca existe')
return self.impl_get_callback()[0] is not None
def _impl_get_display_name(self,
@ -326,7 +296,7 @@ class BaseOption(Base):
config_bag: 'OptionBag',
resetted_opts: List[Base]) -> None:
context = config_bag.context
context._impl_properties_cache.delcache(path)
context.properties_cache.delcache(path)
context._impl_permissives_cache.delcache(path)
if not self.impl_is_optiondescription():
context._impl_values_cache.delcache(path)

8
tiramisu/option/choiceoption.py
View file

@ -55,10 +55,10 @@ class ChoiceOption(Option):
*args,
**kwargs)
async def impl_get_values(self,
def impl_get_values(self,
option_bag):
if isinstance(self._choice_values, Calculation):
values = await self._choice_values.execute(option_bag)
values = self._choice_values.execute(option_bag)
if values is not undefined and not isinstance(values, list):
raise ConfigError(_('the calculated values "{0}" for "{1}" is not a list'
'').format(values, self.impl_getname()))
@ -78,10 +78,10 @@ class ChoiceOption(Option):
values = self._choice_values
self.validate_values(value, values)
async def validate_with_option(self,
def validate_with_option(self,
value: Any,
option_bag: OptionBag) -> None:
values = await self.impl_get_values(option_bag)
values = self.impl_get_values(option_bag)
self.validate_values(value, values)
def validate_values(self,

5
tiramisu/option/domainnameoption.py
View file

@ -196,14 +196,11 @@ class DomainnameOption(StrOption):
allow_ip = self.impl_get_extra('_allow_ip')
allow_cidr_network = self.impl_get_extra('_allow_cidr_network')
# it's an IP so validate with IPOption
if allow_ip is False and allow_cidr_network is False:
raise ValueError(_('must not be an IP'))
if allow_ip is True:
if allow_ip is True and allow_cidr_network is False:
try:
self.impl_get_extra('_ip').second_level_validation(value, warnings_only)
return
except ValueError as err:
if allow_cidr_network is False:
raise err
if allow_cidr_network is True:
self.impl_get_extra('_network').second_level_validation(value, warnings_only)

30
tiramisu/option/dynoptiondescription.py
View file

@ -19,6 +19,7 @@
# 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
@ -43,24 +44,18 @@ 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:
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)
child._setsubdyn(wself)
# add suffixes
if __debug__ and not isinstance(suffixes, Calculation):
raise ConfigError(_('suffixes in dynoptiondescription has to be a calculation'))
@ -82,13 +77,14 @@ class DynOptionDescription(OptionDescription):
suffix = suffix.replace('.', '_')
return suffix
async def get_suffixes(self,
def get_suffixes(self,
config_bag: ConfigBag) -> List[str]:
option_bag = OptionBag()
option_bag.set_option(self,
option_bag = OptionBag(self,
None,
config_bag)
values = await self._suffixes.execute(option_bag)
config_bag,
properties=None,
)
values = self._suffixes.execute(option_bag)
if values is None:
values = []
values_ = []

2
tiramisu/option/ipoption.py
View file

@ -63,8 +63,6 @@ class IPOption(StrOption):
def _validate_ip(self, value):
try:
new_value = str(ip_address(value))
if value != new_value:
raise ValueError(_(f'should be {new_value}'))
except ValueError:
raise ValueError()

94
tiramisu/option/leadership.py
View file

@ -37,7 +37,8 @@ from ..autolib import Calculation, ParamOption
class Leadership(OptionDescription):
__slots__ = ('leader',
'followers')
'followers',
)
def __init__(self,
name: str,
@ -91,18 +92,17 @@ class Leadership(OptionDescription):
child._add_dependency(self)
child._leadership = weakref.ref(self)
if __debug__:
callback, callback_params = leader.impl_get_callback()
options = []
if callback is not None and callback_params is not None:
for callbk in chain(callback_params.args, callback_params.kwargs.values()):
if isinstance(callbk, ParamOption) and callbk.option in followers:
raise ValueError(_("callback of leader's option shall "
"not refered to a follower's ones"))
for prop in leader.impl_getproperties():
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()
@ -121,54 +121,51 @@ class Leadership(OptionDescription):
opt = opt.opt
return opt in self._children[1]
async def reset(self,
def reset(self,
values: Values,
option_bag: OptionBag) -> None:
config_bag = option_bag.config_bag.copy()
config_bag.remove_validation()
for follower in self.get_followers():
soption_bag = OptionBag()
soption_bag.set_option(follower,
soption_bag = OptionBag(follower,
None,
config_bag)
soption_bag.properties = await config_bag.context.cfgimpl_get_settings().getproperties(soption_bag)
await values.reset(soption_bag)
config_bag,
)
values.reset(soption_bag)
async def follower_force_store_value(self,
def follower_force_store_value(self,
values,
value,
option_bag,
owner,
dyn=None,
) -> None:
settings = option_bag.config_bag.context.cfgimpl_get_settings()
settings = option_bag.config_bag.context.get_settings()
if value:
if dyn is None:
dyn = self
for idx, follower in enumerate(await dyn.get_children(option_bag.config_bag)):
foption_bag = OptionBag()
foption_bag.set_option(follower,
for idx, follower in enumerate(dyn.get_children(option_bag.config_bag)):
foption_bag = OptionBag(follower,
None,
option_bag.config_bag)
if 'force_store_value' in await settings.getproperties(foption_bag):
option_bag.config_bag,
)
if 'force_store_value' in foption_bag.properties:
if idx == 0:
indexes = [None]
else:
indexes = range(len(value))
for index in indexes:
foption_bag = OptionBag()
foption_bag.set_option(follower,
foption_bag_index = OptionBag(follower,
index,
option_bag.config_bag)
foption_bag.properties = await settings.getproperties(foption_bag)
await values._p_.setvalue(foption_bag.config_bag.connection,
foption_bag.path,
await values.getvalue(foption_bag),
option_bag.config_bag,
)
values.set_storage_value(foption_bag_index.path,
index,
values.getvalue(foption_bag_index),
owner,
index,
)
async def pop(self,
def pop(self,
values: Values,
index: int,
option_bag: OptionBag,
@ -180,28 +177,27 @@ class Leadership(OptionDescription):
config_bag.remove_validation()
for follower in followers:
follower_path = follower.impl_getpath()
followerlen = await values._p_.get_max_length(config_bag.connection,
follower_path)
soption_bag = OptionBag()
soption_bag.set_option(follower,
followerlen = values.get_max_length(follower_path)
soption_bag = OptionBag(follower,
index,
config_bag)
# do not check force_default_on_freeze or force_metaconfig_on_freeze
soption_bag.properties = set()
is_default = await values.is_default_owner(soption_bag,
validate_meta=False)
config_bag,
properties=set(), # do not check force_default_on_freeze or force_metaconfig_on_freeze
)
is_default = values.is_default_owner(soption_bag,
validate_meta=False,
)
if not is_default and followerlen > index:
await values._p_.resetvalue_index(config_bag.connection,
follower_path,
index)
values.resetvalue_index(follower_path,
index,
)
if followerlen > index + 1:
for idx in range(index + 1, followerlen):
if await values._p_.hasvalue(config_bag.connection,
follower_path,
idx):
await values._p_.reduce_index(config_bag.connection,
follower_path,
idx)
if values.hasvalue(follower_path,
idx,
):
values.reduce_index(follower_path,
idx,
)
def reset_cache(self,
path: str,

42
tiramisu/option/option.py
View file

@ -121,10 +121,11 @@ class Option(BaseOption):
def test_multi_value(value):
if isinstance(value, Calculation):
return
option_bag = OptionBag()
option_bag.set_option(self,
option_bag = OptionBag(self,
None,
undefined)
undefined,
properties=None,
)
try:
self.validate(value)
self.sync_validate_with_option(value,
@ -152,10 +153,11 @@ class Option(BaseOption):
else:
test_multi_value(default_multi)
_setattr(self, '_default_multi', default_multi)
option_bag = OptionBag()
option_bag.set_option(self,
option_bag = OptionBag(self,
None,
undefined)
undefined,
properties=None,
)
self.sync_impl_validate(default,
option_bag)
self.sync_impl_validate(default,
@ -320,7 +322,7 @@ class Option(BaseOption):
'{0}'.format(err),
err_index)
async def impl_validate(self,
def impl_validate(self,
value: Any,
option_bag: OptionBag,
check_error: bool=True) -> None:
@ -350,7 +352,7 @@ class Option(BaseOption):
raise ValueError(_('the value "{}" is not unique'
'').format(val))
async def calculation_validator(val,
def calculation_validator(val,
_index):
for validator in getattr(self, '_validators', []):
calc_is_warnings_only = hasattr(validator, 'warnings_only') and validator.warnings_only
@ -367,7 +369,7 @@ class Option(BaseOption):
soption_bag.index = _index
kwargs['orig_value'] = value
await validator.execute(soption_bag,
validator.execute(soption_bag,
leadership_must_have_index=True,
**kwargs)
except ValueWarning as warn:
@ -379,7 +381,7 @@ class Option(BaseOption):
ValueWarning,
self.__class__.__name__, 356)
async def do_validation(_value,
def do_validation(_value,
_index):
if isinstance(_value, list):
raise ValueError(_('which must not be a list').format(_value,
@ -390,7 +392,7 @@ class Option(BaseOption):
if check_error:
# option validation
self.validate(_value)
await self.validate_with_option(_value,
self.validate_with_option(_value,
option_bag)
if ((check_error and not is_warnings_only) or
(not check_error and is_warnings_only)):
@ -408,23 +410,23 @@ class Option(BaseOption):
self.__class__.__name__, 0)
else:
raise err
await calculation_validator(_value,
calculation_validator(_value,
_index)
try:
val = value
err_index = force_index
if not self.impl_is_multi():
await do_validation(val, None)
do_validation(val, None)
elif force_index is not None:
if self.impl_is_submulti():
if not isinstance(value, list):
raise ValueError(_('which must be a list'))
for val in value:
await do_validation(val,
do_validation(val,
force_index)
_is_not_unique(value, option_bag)
else:
await do_validation(val,
do_validation(val,
force_index)
elif isinstance(value, Calculation) and config_bag is undefined:
pass
@ -438,13 +440,13 @@ class Option(BaseOption):
raise ValueError(_('which "{}" must be a list of list'
'').format(lval))
for val in lval:
await do_validation(val,
do_validation(val,
err_index)
_is_not_unique(lval, option_bag)
else:
# FIXME subtimal, not several time is whole=True!
for err_index, val in enumerate(value):
await do_validation(val,
do_validation(val,
err_index)
_is_not_unique(value, option_bag)
except ValueError as err:
@ -483,7 +485,7 @@ class Option(BaseOption):
option_bag: OptionBag) -> None:
pass
async def validate_with_option(self,
def validate_with_option(self,
value: Any,
option_bag: OptionBag) -> None:
pass
@ -514,10 +516,10 @@ class Option(BaseOption):
def to_dynoption(self,
rootpath: str,
suffix: str,
ori_dyn,
dyn_parent,
) -> SynDynOption:
return SynDynOption(self,
rootpath,
suffix,
ori_dyn,
dyn_parent,
)

118
tiramisu/option/optiondescription.py
View file

@ -37,7 +37,7 @@ class CacheOptionDescription(BaseOption):
def impl_already_build_caches(self) -> bool:
return self.impl_is_readonly()
async def _build_cache(self,
def _build_cache(self,
path='',
_consistencies=None,
_consistencies_id=0,
@ -65,21 +65,22 @@ class CacheOptionDescription(BaseOption):
# cache already set
raise ConfigError(_('option description seems to be part of an other '
'config'))
for option in await self.get_children(config_bag=undefined,
for option in self.get_children(config_bag=undefined,
dyn=False):
if __debug__:
cache_option.append(option)
sub_currpath = currpath + [option.impl_getname()]
subpath = '.'.join(sub_currpath)
if isinstance(option, OptionDescription):
await option._build_cache(subpath,
option._build_cache(subpath,
_consistencies,
_consistencies_id,
sub_currpath,
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)
@ -109,95 +110,87 @@ class CacheOptionDescription(BaseOption):
self._path = self._name
self._set_readonly()
async def impl_build_force_store_values(self,
def impl_build_force_store_values(self,
config_bag: ConfigBag,
) -> None:
async def do_option_bags(option):
def do_option_bags(option):
if option.issubdyn():
dynopt = option.getsubdyn()
rootpath = dynopt.impl_getpath()
subpaths = [rootpath] + option.impl_getpath()[len(rootpath) + 1:].split('.')[1:]
for suffix in await dynopt.get_suffixes(config_bag):
for suffix in dynopt.get_suffixes(config_bag):
path_suffix = dynopt.convert_suffix_to_path(suffix)
subpath = '.'.join([subp + path_suffix for subp in subpaths])
doption = option.to_dynoption(subpath,
suffix,
dynopt,
)
doption_bag = OptionBag()
doption_bag.set_option(doption,
doption_bag = OptionBag(doption,
None,
config_bag,
properties=None,
)
yield doption_bag
else:
option_bag = OptionBag()
option_bag.set_option(option,
option_bag = OptionBag(option,
None,
config_bag)
config_bag,
properties=None,
)
yield option_bag
if 'force_store_value' not in config_bag.properties:
return
values = config_bag.context.cfgimpl_get_values()
values = config_bag.context.get_values()
for option in self._cache_force_store_values:
if option.impl_is_follower():
leader = option.impl_get_leadership().get_leader()
async for leader_option_bag in do_option_bags(leader):
for leader_option_bag in do_option_bags(leader):
leader_option_bag.properties = frozenset()
follower_len = len(await values.getvalue(leader_option_bag))
follower_len = len(values.getvalue(leader_option_bag))
if option.issubdyn():
subpath = leader_option_bag.option.rootpath
doption = option.to_dynoption(subpath,
leader_option_bag.option.impl_getsuffix(),
leader_option_bag.option.ori_dyn,
leader_option_bag.option.dyn_parent,
)
else:
doption = option
subpath = doption.impl_getpath()
for index in range(follower_len):
if await values._p_.hasvalue(config_bag.connection,
subpath,
index,
):
if values.hasvalue(subpath, index):
continue
option_bag = OptionBag()
option_bag.set_option(doption,
option_bag = OptionBag(doption,
index,
config_bag,
properties=frozenset(),
)
option_bag.properties = frozenset()
value = await values.getvalue(option_bag)
value = values.getvalue(option_bag)
if value is None:
continue
await values._p_.setvalue(config_bag.connection,
subpath,
value,
owners.forced,
values.set_storage_value(subpath,
index,
False)
else:
async for option_bag in do_option_bags(option):
option_bag.properties = frozenset()
value = await values.getvalue(option_bag)
if value is None:
continue
if await values._p_.hasvalue(config_bag.connection,
option_bag.option.impl_getpath(),
):
continue
await values._p_.setvalue(config_bag.connection,
option_bag.path,
value,
owners.forced,
)
else:
for option_bag in do_option_bags(option):
option_bag.properties = frozenset()
value = values.getvalue(option_bag)
if value is None:
continue
if values.hasvalue(option_bag.option.impl_getpath()):
continue
values.set_storage_value(option_bag.path,
None,
False,
value,
owners.forced,
)
class OptionDescriptionWalk(CacheOptionDescription):
__slots__ = ('_children',)
async def get_child(self,
def get_child(self,
name: str,
config_bag: ConfigBag,
subpath: str,
@ -212,36 +205,39 @@ class OptionDescriptionWalk(CacheOptionDescription):
return option
# if dyn
for child in self._children[1]:
if child.impl_is_dynoptiondescription():
if not child.impl_is_dynoptiondescription():
continue
cname = child.impl_getname()
if name.startswith(cname):
for suffix in await child.get_suffixes(config_bag):
if name == cname + child.convert_suffix_to_path(suffix):
if not name.startswith(cname):
continue
for suffix in child.get_suffixes(config_bag):
if name != cname + child.convert_suffix_to_path(suffix):
continue
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()}"'
))
async def get_children(self,
def get_children(self,
config_bag: Union[ConfigBag, Undefined],
dyn: bool=True,
) -> Union[BaseOption, SynDynOptionDescription]:
if not dyn or config_bag is undefined or \
config_bag.context.cfgimpl_get_description() == self:
config_bag.context.get_description() == self:
subpath = ''
else:
subpath = self.impl_getpath()
children = []
for child in self._children[1]:
if dyn and child.impl_is_dynoptiondescription():
for suffix in await child.get_suffixes(config_bag):
for suffix in child.get_suffixes(config_bag):
children.append(child.to_dynoption(subpath,
suffix,
child))
@ -249,18 +245,20 @@ class OptionDescriptionWalk(CacheOptionDescription):
children.append(child)
return children
async def get_children_recursively(self,
def get_children_recursively(self,
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 await self_opt.get_children(config_bag):
for option in self_opt.get_children(config_bag):
if option.impl_is_optiondescription():
async for subopt in option.get_children_recursively(bytype,
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)):
@ -317,6 +315,12 @@ 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

7
tiramisu/option/symlinkoption.py
View file

@ -20,6 +20,7 @@
# ____________________________________________________________
from typing import Any
from .baseoption import BaseOption, valid_name
from ..error import ConfigError
from ..i18n import _
@ -47,6 +48,12 @@ 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

13
tiramisu/option/syndynoption.py
View file

@ -29,18 +29,19 @@ class SynDynOption:
__slots__ = ('rootpath',
'opt',
'suffix',
'ori_dyn',
'dyn_parent',
'__weakref__')
def __init__(self,
opt: BaseOption,
rootpath: str,
suffix: str,
ori_dyn) -> None:
dyn_parent,
) -> None:
self.opt = opt
self.rootpath = rootpath
self.suffix = suffix
self.ori_dyn = ori_dyn
self.dyn_parent = dyn_parent
def __getattr__(self,
name: str) -> Any:
@ -56,11 +57,11 @@ class SynDynOption:
self.suffix == left.suffix
def impl_getname(self) -> str:
return self.opt.impl_getname() + self.ori_dyn.convert_suffix_to_path(self.suffix)
return self.opt.impl_getname() + self.dyn_parent.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.ori_dyn.convert_suffix_to_path(self.suffix),
suffix=self.dyn_parent.convert_suffix_to_path(self.suffix),
)
def impl_getsuffix(self) -> str:
@ -78,5 +79,5 @@ class SynDynOption:
rootpath = self.rootpath.rsplit('.', 1)[0]
return leadership.to_dynoption(rootpath,
self.suffix,
self.ori_dyn,
self.dyn_parent,
)

18
tiramisu/option/syndynoptiondescription.py
View file

@ -59,7 +59,7 @@ class SynDynOptionDescription:
def impl_getopt(self) -> BaseOption:
return self.opt
async def get_child(self,
def get_child(self,
name: str,
config_bag: ConfigBag,
subpath: str) -> BaseOption:
@ -85,13 +85,13 @@ class SynDynOptionDescription:
def impl_is_dynoptiondescription(self) -> bool:
return True
async def get_children(self,
def get_children(self,
config_bag: ConfigBag,
dyn: bool=True,
):
subpath = self.impl_getpath()
children = []
for child in await self.opt.get_children(config_bag):
for child in self.opt.get_children(config_bag):
children.append(child.to_dynoption(subpath,
self._suffix,
self.ori_dyn,
@ -101,12 +101,12 @@ class SynDynOptionDescription:
def impl_is_dynsymlinkoption(self) -> bool:
return True
async def get_children_recursively(self,
def get_children_recursively(self,
bytype: Optional[BaseOption],
byname: Optional[str],
config_bag: ConfigBag,
self_opt: BaseOption=None) -> BaseOption:
async for option in self.opt.get_children_recursively(bytype,
for option in self.opt.get_children_recursively(bytype,
byname,
config_bag,
self):
@ -147,19 +147,19 @@ class SynDynLeadership(SynDynOptionDescription):
config_bag,
resetted_opts)
async def pop(self,
def pop(self,
*args,
**kwargs) -> None:
await self.opt.pop(*args,
self.opt.pop(*args,
followers=self.get_followers(),
**kwargs)
async def follower_force_store_value(self,
def follower_force_store_value(self,
values,
value,
option_bag,
owner) -> None:
await self.opt.follower_force_store_value(values,
self.opt.follower_force_store_value(values,
value,
option_bag,
owner,

360
tiramisu/setting.py
View file

@ -18,7 +18,6 @@
from itertools import chain
from .error import PropertiesOptionError, ConstError, ConfigError, LeadershipError, display_list
from .i18n import _
from .asyncinit import asyncinit
"""If cache and expire is enable, time before cache is expired.
@ -103,19 +102,35 @@ 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',
@ -124,11 +139,23 @@ 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',
@ -136,39 +163,41 @@ 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):
self.option = None
def set_option(self,
def __init__(self,
option,
index,
config_bag):
if config_bag is undefined:
self.path = None
else:
self.path = option.impl_getpath()
config_bag,
path=None,
properties=undefined,
ori_option=None,
apply_requires=True,
):
self.index = index
self.option = option
self.config_bag = config_bag
self.option = option
if ori_option is not None:
self.ori_option = ori_option
if config_bag is undefined:
self.path = path
elif path:
self.path = path
elif option:
self.path = option.impl_getpath()
if properties is undefined:
self.properties = config_bag.context.get_settings().getproperties(self, apply_requires=apply_requires)
if properties is not undefined:
self.properties = properties
def __getattr__(self, key):
if key == 'ori_option':
return self.option
elif key == 'apply_requires':
return True
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']:
try:
@ -179,10 +208,8 @@ class OptionBag:
raise KeyError(_('cannot delete key "{}" for OptionBag').format(key)) # pragma: no cover
def copy(self):
option_bag = OptionBag()
option_bag = OptionBag(None, None, None)
for key in self.__slots__:
if key == 'properties' and self.config_bag is undefined:
continue
if hasattr(self, key):
setattr(option_bag, key, getattr(self, key))
return option_bag
@ -195,7 +222,6 @@ class ConfigBag:
'is_unrestraint',
'permissives', # permissives for current context
'expiration_time', # EXPIRATION_TIME
'connection',
)
def __init__(self,
@ -239,10 +265,7 @@ class ConfigBag:
def copy(self):
kwargs = {}
for key in self.__slots__:
try:
kwargs[key] = getattr(self, key)
except KeyError:
pass
return ConfigBag(**kwargs)
@ -255,13 +278,15 @@ 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))
@ -295,7 +320,7 @@ class GroupModule(_NameSpace):
class OwnerModule(_NameSpace):
"""emulates a module to manage unique owner names.
owners are living in `Config._cfgimpl_value_owners`
owners are living in `Config._value_owners`
"""
class Owner(str):
"""allowed owner names
@ -349,32 +374,21 @@ 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"
__slots__ = ('_p_',
'_pp_',
__slots__ = ('_properties',
'_permissives',
'_permissives',
'__weakref__',
'ro_append',
'ro_remove',
'rw_append',
'rw_remove',
'default_properties')
'default_properties',
)
def __init__(self,
properties,
permissives):
def __init__(self):
"""
initializer
@ -382,8 +396,8 @@ class Settings(object):
:param storage: the storage type
"""
# generic owner
self._p_ = properties
self._pp_ = permissives
self._properties = {}
self._permissives = {}
self.default_properties = DEFAULT_PROPERTIES
self.ro_append = RO_APPEND
self.ro_remove = RO_REMOVE
@ -393,20 +407,18 @@ class Settings(object):
# ____________________________________________________________
# get properties and permissive methods
async def get_context_properties(self,
connection,
cache):
def get_context_properties(self,
cache,
):
is_cached, props, validated = cache.getcache(None,
None,
None,
{},
{},
'context_props')
'context_props',
)
if not is_cached:
props = await self._p_.getproperties(connection,
None,
None,
self.default_properties)
props = self._properties.get(None, {}).get(None, self.default_properties)
cache.setcache(None,
None,
props,
@ -415,11 +427,23 @@ class Settings(object):
True)
return props
async def getproperties(self,
def _getproperties(self,
path,
index,
default_properties,
):
if path not in self._properties:
ret = frozenset(default_properties)
else:
ret = self._properties[path].get(index, frozenset(default_properties))
return ret
def getproperties(self,
option_bag,
apply_requires=True,
uncalculated=False,
help_property=False):
help_property=False,
):
"""
"""
option = option_bag.option
@ -429,28 +453,27 @@ 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._impl_properties_cache
cache = config_bag.context.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:
props = set()
# if index, get option's properties (without index) too
p_props = await self._p_.getproperties(config_bag.connection,
path,
p_props = self._getproperties(path,
None,
option.impl_getproperties())
option.impl_getproperties(),
)
if index is not None:
p_props = chain(p_props,
await self._p_.getproperties(config_bag.connection,
path,
index,
option.impl_getproperties()))
self._properties.get(path, {}).get(index, option.impl_getproperties())
)
for prop in p_props:
if uncalculated or isinstance(prop, str):
if not help_property:
@ -459,12 +482,12 @@ class Settings(object):
props.add((prop, prop))
elif apply_requires:
if not help_property:
new_prop = await prop.execute(option_bag,
new_prop = prop.execute(option_bag,
leadership_must_have_index=True,
for_settings=True,
)
else:
new_prop = await prop.help(option_bag,
new_prop = prop.help(option_bag,
leadership_must_have_index=True,
for_settings=True,
)
@ -482,7 +505,7 @@ class Settings(object):
new_prop not in ALLOWED_LEADER_PROPERTIES:
raise LeadershipError(_('leader cannot have "{}" property').format(new_prop))
props.add(new_prop)
props -= await self.getpermissives(option_bag)
props -= self.getpermissives(option_bag)
if not uncalculated and apply_requires and not config_bag.is_unrestraint and not help_property:
cache.setcache(path,
index,
@ -492,35 +515,38 @@ class Settings(object):
True)
return props
async def has_properties_index(self,
def has_properties_index(self,
option_bag):
option = option_bag.option
if option.impl_is_symlinkoption():
option = option.impl_getopt()
path = option.impl_getpath()
p_props = await self._p_.getproperties(option_bag.config_bag.connection,
path,
None,
option.impl_getproperties())
p_props = self._properties.get(path, {}).get(None, option.impl_getproperties())
if option_bag.index is not None:
p_props = chain(p_props,
await self._p_.getproperties(option_bag.config_bag.connection,
path,
option_bag.index,
option.impl_getproperties()))
self._properties.get(path, {}).get(option_bag.index, option.impl_getproperties()),
)
for prop in p_props:
if not isinstance(prop, str) and prop.has_index(option_bag.option):
return True
return False
async def get_context_permissives(self,
connection):
return await self.getpermissives(None,
connection=connection)
def get_context_permissives(self):
return self.getpermissives(None)
async def getpermissives(self,
def _getpermissives(self,
path,
index,
):
if not path in self._permissives:
ret = frozenset()
else:
ret = self._permissives[path].get(index, frozenset())
return ret
def getpermissives(self,
option_bag,
connection=None):
):
if option_bag is None:
path = None
index = None
@ -532,34 +558,26 @@ class Settings(object):
else:
path = option_bag.path
index = option_bag.index
connection = option_bag.config_bag.connection
permissives = await self._pp_.getpermissives(connection,
path,
None)
permissives = self._getpermissives(path,
None,
)
if index is not None:
option_permissives = await self._pp_.getpermissives(connection,
path,
index)
option_permissives = self._permissives.get(path, {}).get(index, set())
permissives = frozenset(option_permissives | permissives)
return permissives
#____________________________________________________________
# set methods
async def set_context_properties(self,
connection,
properties,
context):
await self._p_.setproperties(connection,
None,
None,
properties)
await context.cfgimpl_reset_cache(None)
def set_context_properties(self, properties, context):
self._properties.setdefault(None, {})[None] = properties
context.reset_cache(None)
async def setproperties(self,
def setproperties(self,
path,
properties,
option_bag,
context):
context,
):
"""save properties for specified path
(never save properties if same has option properties)
"""
@ -579,25 +597,22 @@ 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()))
await self._p_.setproperties(option_bag.config_bag.connection,
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
await context.cfgimpl_reset_cache(option_bag)
context.reset_cache(option_bag)
option_bag.properties = properties
async def set_context_permissives(self,
connection,
permissives):
await self.setpermissives(None,
def set_context_permissives(self,
permissives,
connection=connection)
):
self.setpermissives(None,
permissives,
)
async def setpermissives(self,
def setpermissives(self,
option_bag,
permissives,
connection=None):
):
"""
enables us to put the permissives in the storage
@ -616,7 +631,6 @@ class Settings(object):
"").format(opt.impl_get_display_name()))
path = option_bag.path
index = option_bag.index
connection = option_bag.config_bag.connection
else:
path = None
index = None
@ -624,19 +638,17 @@ class Settings(object):
if forbidden_permissives:
raise ConfigError(_('cannot add those permissives: {0}').format(
' '.join(forbidden_permissives)))
await self._pp_.setpermissives(connection,
path,
index,
permissives)
self._permissives.setdefault(path, {})[index] = permissives
if option_bag is not None:
await option_bag.config_bag.context.cfgimpl_reset_cache(option_bag)
option_bag.config_bag.context.reset_cache(option_bag)
#____________________________________________________________
# reset methods
async def reset(self,
def reset(self,
option_bag,
config_bag):
config_bag,
):
if option_bag is None:
opt = None
path = None
@ -648,12 +660,11 @@ class Settings(object):
"").format(opt.impl_get_display_name())
path = option_bag.path
index = option_bag.index
await self._p_.delproperties(config_bag.connection,
path,
index)
await config_bag.context.cfgimpl_reset_cache(option_bag)
if path in self._properties and index in self._properties[path]:
del(self._properties[path][index])
config_bag.context.reset_cache(option_bag)
async def reset_permissives(self,
def reset_permissives(self,
option_bag,
config_bag):
if option_bag is None:
@ -667,23 +678,24 @@ class Settings(object):
"").format(opt.impl_get_display_name())
index = option_bag.index
path = option_bag.path
await self._pp_.delpermissive(config_bag.connection,
path,
index)
await config_bag.context.cfgimpl_reset_cache(option_bag)
if path in self._permissives and index in self._permissives[path]:
del(self._permissives[path][index])
config_bag.context.reset_cache(option_bag)
#____________________________________________________________
# validate properties
async def calc_raises_properties(self,
def calc_raises_properties(self,
option_bag,
apply_requires=True,
uncalculated=False):
if not uncalculated and apply_requires and option_bag.properties_setted:
uncalculated=False,
):
if not uncalculated and apply_requires:
option_properties = option_bag.properties
else:
option_properties = await self.getproperties(option_bag,
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)
@ -700,22 +712,25 @@ class Settings(object):
# at this point it should not remain any property for the option
return properties
async def validate_properties(self,
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
return
properties = await self.calc_raises_properties(option_bag)
properties = self.calc_raises_properties(option_bag)
if properties != frozenset():
if need_help:
help_properties = dict(await self.getproperties(option_bag,
help_property=True))
help_properties = dict(self.getproperties(option_bag,
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:
@ -729,7 +744,7 @@ class Settings(object):
value,
option_bag):
if 'mandatory' in option_bag.config_bag.properties:
values = option_bag.config_bag.context.cfgimpl_get_values()
values = option_bag.config_bag.context.get_values()
if option_bag.option.impl_is_follower():
force_allow_empty_list = True
else:
@ -739,7 +754,8 @@ 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)
@ -765,14 +781,12 @@ class Settings(object):
#____________________________________________________________
# read only/read write
async def _read(self,
def _read(self,
remove,
append,
config_bag):
props = await self._p_.getproperties(config_bag.connection,
None,
None,
self.default_properties)
config_bag,
):
props = self._properties.get(None, {}).get(None, self.default_properties)
modified = False
if remove & props:
props = props - remove
@ -781,20 +795,24 @@ class Settings(object):
props = props | append
modified = True
if modified:
await self.set_context_properties(config_bag.connection,
frozenset(props),
config_bag.context)
self.set_context_properties(frozenset(props),
config_bag.context,
)
async def read_only(self,
config_bag):
def read_only(self,
config_bag,
):
"convenience method to freeze, hide and disable"
await self._read(self.ro_remove,
self._read(self.ro_remove,
self.ro_append,
config_bag)
config_bag,
)
async def read_write(self,
config_bag):
def read_write(self,
config_bag,
):
"convenience method to freeze, hide and disable"
await self._read(self.rw_remove,
self._read(self.rw_remove,
self.rw_append,
config_bag)
config_bag,
)

150
tiramisu/storage/__init__.py
View file

@ -1,150 +0,0 @@
# Copyright (C) 2013-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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/>.
# ____________________________________________________________
"""Config's informations are, by default, volatiles. This means, all values and
settings changes will be lost.
The storage is the system Tiramisu uses to communicate with various DB.
Storage is basic components used to set Config informations in DB.
"""
from time import time
from random import randint
from os import environ
from os.path import split
from typing import Dict
from ..error import ConfigError
from ..i18n import _
from .cacheobj import Cache
DEFAULT_STORAGE = MEMORY_STORAGE = 'dictionary'
MODULE_PATH = split(split(split(__file__)[0])[0])[1]
class Storage:
"""Object to store storage's type. If a Config is already set,
default storage is store as selected storage. You cannot change it
after.
"""
def __init__(self,
engine=None) -> None:
self.storage_type = engine
self.mod = None
self.kwargs = {}
def engine(self,
engine) -> None:
if self.mod is not None:
raise ValueError(_('cannot change setting when storage is already in use'))
self.storage_type = engine
def setting(self,
**kwargs: Dict[str, str]) -> None:
if self.mod is not None:
raise ValueError(_('cannot change setting when storage is already in use'))
self.kwargs = kwargs
async def get(self):
if self.storage_type is None:
self.storage_type = environ.get('TIRAMISU_STORAGE', DEFAULT_STORAGE)
if self.mod is None:
modulepath = '{0}.storage.{1}'.format(MODULE_PATH,
self.storage_type)
try:
mod = __import__(modulepath)
except ImportError: # pragma: no cover
raise SystemError(_('cannot import the storage {0}').format(
self.storage_type))
for token in modulepath.split(".")[1:]:
mod = getattr(mod, token)
self.mod = mod
for key, value in self.kwargs.items():
setattr(mod.SETTING, key, value)
del self.kwargs
await self.mod.init()
return self.mod
default_storage = Storage()
memory_storage = Storage(engine=MEMORY_STORAGE)
def gen_storage_id(session_id,
config):
if session_id is not None:
return session_id
return 'c' + str(id(config)) + str(int(time())) + str(randint(0, 50000))
async def get_storages(context,
session_id,
delete_old_session,
storage,
connection):
session_id = gen_storage_id(session_id,
context)
if storage is None:
storage = default_storage
imp = await storage.get()
imp_storage = await imp.Storage(connection,
session_id,
delete_old_session)
properties = imp.Properties(imp_storage)
permissives = imp.Permissives(imp_storage)
values = imp.Values(imp_storage)
return storage, properties, permissives, values, session_id
async def get_default_values_storages(connection):
imp = await memory_storage.get()
storage = await imp.Storage(connection,
'__validator_storage',
delete_old_session=True)
return imp.Values(storage)
async def get_default_settings_storages(connection):
imp = await memory_storage.get()
storage = await imp.Storage(connection,
'__validator_storage',
delete_old_session=True)
properties = imp.Properties(storage)
permissives = imp.Permissives(storage)
return properties, permissives
async def list_sessions(storage=default_storage):
"""List all available session
"""
stor = await storage.get()
return await stor.list_sessions()
async def delete_session(session_id,
storage=default_storage):
"""Delete a selected session, be careful, you can deleted a session
use by an other instance
:params session_id: id of session to delete
"""
storage_module = await storage.get()
await storage_module.value.delete_session(session_id)
await storage_module.storage.delete_session(session_id)
__all__ = ('list_sessions', 'delete_session')

0
tiramisu/storage/cache/__init__.py vendored
View file

42
tiramisu/storage/cache/dictionary.py vendored
View file

@ -1,42 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright (C) 2018-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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/>.
# ____________________________________________________________
class Cache:
__slots__ = ('_cache',)
def __init__(self):
self._cache = {}
def setcache(self, path, index, val, time, validated):
self._cache.setdefault(path, {})[index] = (val, int(time), validated)
def getcache(self, path, index):
values = self._cache.get(path)
if values is None:
return
return values.get(index)
def delcache(self, path):
if path in self._cache:
del self._cache[path]
def get_cached(self):
return self._cache
def reset_all_cache(self):
self._cache.clear()

36
tiramisu/storage/dictionary/__init__.py
View file

@ -1,36 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright (C) 2013-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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/>.
# ____________________________________________________________
"""Default plugin for storage. All informations are store in a simple
dictionary in memory.
The advantage of this solution is that you can easily create a Config and
use it. But if something goes wrong, you will lost your modifications.
"""
from .value import Values
from .setting import Properties, Permissives
from .storage import PERSISTENT, SETTING, Storage, list_sessions, init, Connection
__all__ = ('PERSISTENT',
'SETTING',
'Values',
'Properties',
'Permissives',
'Storage',
'init',
'Connection',
'list_sessions')

127
tiramisu/storage/dictionary/setting.py
View file

@ -1,127 +0,0 @@
# -*- coding: utf-8 -*-
"default plugin for setting: set it in a simple dictionary"
# Copyright (C) 2013-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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 copy import deepcopy
from ...log import log
class Properties:
__slots__ = ('_storage',)
def __init__(self, storage):
# properties attribute: the name of a property enables this property
# key is None for global properties
self._storage = storage
# properties
async def setproperties(self,
connection,
path,
index,
properties):
log.debug('setproperties %s %s %s', path, index, properties)
self._storage.get_properties().setdefault(path, {})[index] = properties
async def getproperties(self,
connection,
path,
index,
default_properties):
properties = self._storage.get_properties()
if path not in properties:
ret = frozenset(default_properties)
else:
ret = properties[path].get(index, frozenset(default_properties))
log.debug('getproperties %s %s %s', path, index, ret)
return ret
async def delproperties(self,
connection,
path,
index):
log.debug('delproperties %s', path)
properties = self._storage.get_properties()
if path in properties and index in properties[path]:
del(properties[path][index])
async def exportation(self,
connection):
"""return all modified settings in a dictionary
example: {'path1': set(['prop1', 'prop2'])}
"""
return deepcopy(self._storage.get_properties())
async def importation(self,
connection,
properties):
self._storage.set_properties(properties)
def getconnection(self):
return self._storage.getconnection()
class Permissives:
__slots__ = ('_storage',)
def __init__(self, storage):
# permissive properties
self._storage = storage
async def setpermissives(self,
connection,
path,
index,
permissives):
log.debug('setpermissives %s %s', path, permissives)
self._storage.get_permissives().setdefault(path, {})[index] = permissives
async def getpermissives(self,
connection,
path,
index):
permissives = self._storage.get_permissives()
if not path in permissives:
ret = frozenset()
else:
ret = permissives[path].get(index, frozenset())
log.debug('getpermissives %s %s', path, ret)
return ret
async def delpermissive(self,
connection,
path,
index):
log.debug('delpermissive %s', path)
permissives = self._storage.get_permissives()
if path in permissives and index in permissives[path]:
del(permissives[path][index])
async def exportation(self,
connection):
"""return all modified permissives in a dictionary
example: {'path1': set(['perm1', 'perm2'])}
"""
return deepcopy(self._storage.get_permissives())
async def importation(self,
connection,
permissives):
self._storage.set_permissives(permissives)
def getconnection(self):
return self._storage.getconnection()

120
tiramisu/storage/dictionary/storage.py
View file

@ -1,120 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright (C) 2013-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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 ...i18n import _
from ...error import ConflictError
from ...asyncinit import asyncinit
class Setting:
"""Dictionary storage has no particular setting.
"""
__slots__ = tuple()
SETTING = Setting()
_list_sessions = {}
PERSISTENT = True
async def init():
pass
class Connection:
async def __aenter__(self):
return self
async def __aexit__(self,
type,
value,
traceback):
pass
async def list_sessions():
lst = list(_list_sessions.keys())
if '__validator_storage' in lst:
lst.remove('__validator_storage')
return lst
async def delete_session(session_id):
try:
del _list_sessions[session_id]
except KeyError:
pass
@asyncinit
class Storage:
__slots__ = ('session_id',)
storage = 'dictionary'
def add_session(self):
# values (('path1',), (index1,), (value1,), ('owner1'))
_list_sessions[self.session_id] = {'values': ([], [], [], []),
'informations': {},
'properties': {},
'permissives': {}}
async def __init__(self,
connection: Connection,
session_id: str,
delete_old_session: bool) -> None:
if not isinstance(session_id, str):
raise ValueError(_('session_id has to be a string'))
self.session_id = session_id
if self.session_id not in _list_sessions:
self.add_session()
async def delete_session(self):
await delete_session(self.session_id)
async def list_sessions(self):
return await list_sessions()
def get_session(self):
if self.session_id not in _list_sessions:
self.add_session()
return _list_sessions.get(self.session_id, {})
def get_values(self):
return self.get_session()['values']
def set_values(self, values):
self.get_session()['values'] = values
def get_informations(self):
return self.get_session()['informations']
def set_informations(self, informations):
self.get_session()['informations'] = informations
def get_properties(self):
return self.get_session()['properties']
def set_properties(self, properties):
self.get_session()['properties'] = properties
def get_permissives(self):
return self.get_session()['permissives']
def set_permissives(self, permissives):
self.get_session()['permissives'] = permissives
def getconnection(self):
return Connection()

323
tiramisu/storage/dictionary/value.py
View file

@ -1,323 +0,0 @@
# -*- coding: utf-8 -*-
"default plugin for value: set it in a simple dictionary"
# Copyright (C) 2013-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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 ...setting import undefined
from ...i18n import _
from ...log import log
from .storage import delete_session
from copy import deepcopy
class Values:
__slots__ = ('_values',
'_storage',
'__weakref__')
def __init__(self, storage):
"""init plugin means create values storage
"""
self._storage = storage
def _setvalue_info(self, nb, idx, value, index, follower_idx=None):
lst = self._storage.get_values()[nb]
if index is None or nb == 0:
# not follower or path
lst[idx] = value
else:
# follower
if nb == 1 and index in lst[idx]:
follower_idx = lst[idx].index(index)
tval = list(lst[idx])
if follower_idx is None:
tval.append(value)
else:
tval[follower_idx] = value
lst[idx] = tval
return follower_idx
def _add_new_value(self, index, nb, value):
if index is None or nb == 0:
# not follower or path
self._storage.get_values()[nb].append(value)
else:
# follower
self._storage.get_values()[nb].append([value])
def _add_new_value(self, index, nb, value):
if index is None or nb == 0:
# not follower or path
self._storage.get_values()[nb].append(value)
else:
# follower
self._storage.get_values()[nb].append([value])
# value
async def setvalue(self,
connection,
path,
value,
owner,
index,
new=False):
"""set value for a path
a specified value must be associated to an owner
"""
log.debug('setvalue %s %s %s %s %s', path, value, owner, index, id(self))
#if isinstance(value, list):
# value = value
values = self._storage.get_values()
if not new and path in values[0]:
idx = values[0].index(path)
self._setvalue_info(0, idx, path, index)
follower_idx = self._setvalue_info(1, idx, index, index)
self._setvalue_info(2, idx, value, index, follower_idx)
self._setvalue_info(3, idx, owner, index, follower_idx)
else:
self._add_new_value(index, 0, path)
self._add_new_value(index, 1, index)
self._add_new_value(index, 2, value)
self._add_new_value(index, 3, owner)
async def hasvalue(self,
connection,
path,
index=None):
"""if path has a value
return: boolean
"""
values = self._storage.get_values()
has_path = path in values[0]
log.debug('hasvalue %s %s %s %s', path, index, has_path, id(self))
if index is None:
return has_path
elif has_path:
path_idx = values[0].index(path)
indexes = values[1][path_idx]
return index in indexes
return False
async def reduce_index(self,
connection,
path,
index):
"""
_values == ((path1, path2), ((idx1_1, idx1_2), None), ((value1_1, value1_2), value2), ((owner1_1, owner1_2), owner2))
"""
log.debug('reduce_index %s %s %s', path, index, id(self))
values = self._storage.get_values()
path_idx = values[0].index(path)
# get the "index" position
subidx = values[1][path_idx].index(index)
# reduce to one the index
values[1][path_idx][subidx] -= 1
async def resetvalue_index(self,
connection,
path,
index):
log.debug('resetvalue_index %s %s %s', path, index, id(self))
values = self._storage.get_values()
def _resetvalue(nb):
del self._storage.get_values()[nb][path_idx]
def _resetvalue_index(nb):
del self._storage.get_values()[nb][path_idx][subidx]
path_idx = values[0].index(path)
indexes = values[1][path_idx]
if index in indexes:
subidx = indexes.index(index)
if len(values[1][path_idx]) == 1:
_resetvalue(0)
_resetvalue(1)
_resetvalue(2)
_resetvalue(3)
else:
_resetvalue_index(1)
_resetvalue_index(2)
_resetvalue_index(3)
async def resetvalue(self,
connection,
path):
"""remove value means delete value in storage
"""
log.debug('resetvalue %s %s', path, id(self))
values = self._storage.get_values()
def _resetvalue(nb):
values[nb].pop(idx)
if path in values[0]:
idx = values[0].index(path)
_resetvalue(0)
_resetvalue(1)
_resetvalue(2)
_resetvalue(3)
# owner
async def setowner(self,
connection,
path,
owner,
index):
"""change owner for a path
"""
values = self._storage.get_values()
idx = values[0].index(path)
if index is None:
follower_idx = None
else:
follower_idx = values[1][idx].index(index)
self._setvalue_info(3, idx, owner, index, follower_idx)
async def getowner(self,
connection,
path,
default,
index=None,
with_value=False):
"""get owner for a path
return: owner object
"""
owner, value = self._getvalue(path,
index,
with_value)
if owner is undefined:
owner = default
log.debug('getvalue %s %s %s %s %s', path, index, value, owner, id(self))
if with_value:
return owner, value
else:
return owner
def _getvalue(self,
path,
index,
with_value):
"""
_values == ((path1, path2), ((idx1_1, idx1_2), None), ((value1_1, value1_2), value2), ((owner1_1, owner1_2), owner2))
"""
values = self._storage.get_values()
value = undefined
if path in values[0]:
path_idx = values[0].index(path)
indexes = values[1][path_idx]
if indexes is None:
if index is not None: # pragma: no cover
raise ValueError('index is forbidden for {}'.format(path))
owner = values[3][path_idx]
if with_value:
value = values[2][path_idx]
else:
if index is None: # pragma: no cover
raise ValueError('index is mandatory for {}'.format(path))
if index in indexes:
subidx = indexes.index(index)
owner = values[3][path_idx][subidx]
if with_value:
value = values[2][path_idx][subidx]
else:
owner = undefined
else:
owner = undefined
if isinstance(value, tuple):
value = list(value)
return owner, value
async def set_information(self,
connection,
path,
key,
value):
"""updates the information's attribute
(which is a dictionary)
:param key: information's key (ex: "help", "doc"
:param value: information's value (ex: "the help string")
"""
informations = self._storage.get_informations()
informations.setdefault(path, {})
informations[path][key] = value
async def get_information(self,
connection,
path,
key,
):
"""retrieves one information's item
:param key: the item string (ex: "help")
"""
return self._storage.get_informations().get(path, {})[key]
async def del_information(self,
connection,
path,
key,
raises):
informations = self._storage.get_informations()
if path in informations and key in informations[path]:
del informations[path][key]
else:
if raises:
raise ValueError(_("information's item not found {0}").format(key))
async def list_information(self,
connection,
path):
informations = self._storage.get_informations()
if path in informations:
return list(informations[path].keys())
else:
return []
async def del_informations(self,
connection):
self._storage.set_informations({})
async def exportation_informations(self,
connection,
):
return deepcopy(self._storage.get_informations())
async def importation_informations(self,
connection,
informations,
):
#deepcopy(informations)
return self._storage.set_informations(informations)
async def exportation(self,
connection):
return deepcopy(self._storage.get_values())
async def importation(self,
connection,
export):
self._storage.set_values(deepcopy(export))
async def get_max_length(self,
connection,
path):
values = self._storage.get_values()
if path in values[0]:
idx = values[0].index(path)
else:
return 0
return max(values[1][idx]) + 1
def getconnection(self):
return self._storage.getconnection()

32
tiramisu/storage/postgres/__init__.py
View file

@ -1,32 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright (C) 2020-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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/>.
# ____________________________________________________________
"""Postgres plugin for storage.
"""
from .value import Values
from .setting import Properties, Permissives
from .storage import PERSISTENT, SETTING, Storage, list_sessions, init, Connection
__all__ = ('PERSISTENT',
'SETTING',
'Values',
'Properties',
'Permissives',
'Storage',
'init',
'Connection',
'list_sessions')

179
tiramisu/storage/postgres/setting.py
View file

@ -1,179 +0,0 @@
# -*- coding: utf-8 -*-
"default plugin for setting: set it in a simple dictionary"
# Copyright (C) 2020-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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/>.
# ____________________________________________________________
try:
from cPickle import loads, dumps
except ImportError:
from pickle import loads, dumps
from ...log import log
class Properties:
__slots__ = ('_storage',)
def __init__(self, storage):
self._storage = storage
# properties
async def setproperties(self,
connection,
path,
index,
properties):
index = self._storage.convert_index(index)
path = self._storage.convert_path(path)
await self.delproperties(connection, path, index)
sql = "INSERT INTO property(path, idx, properties, session_id) VALUES ($1, $2, $3, $4)"
params = [path, index, dumps(properties), self._storage.database_id]
await connection.execute(sql, *params)
async def getproperties(self,
connection,
path,
index,
default_properties):
index = self._storage.convert_index(index)
path = self._storage.convert_path(path)
sql = 'SELECT properties FROM property WHERE path = $1 AND session_id = $2 AND idx = $3'
params = [path, self._storage.database_id, index]
value = await connection.fetchval(sql, *params)
if value is None:
return set(default_properties)
else:
return set(loads(value))
async def delproperties(self,
connection,
path,
index):
index = self._storage.convert_index(index)
path = self._storage.convert_path(path)
sql = 'DELETE FROM property WHERE session_id = $1 AND path = $2 AND idx = $3'
params = [self._storage.database_id, path, index]
await connection.execute(sql, *params)
async def exportation(self,
connection):
"""return all modified settings in a dictionary
example: {'path1': set(['prop1', 'prop2'])}
"""
ret = {}
for path, idx, properties, _ in await connection.fetch("SELECT * FROM property "
"WHERE session_id = $1",
self._storage.database_id):
idx = self._storage.load_index(idx)
path = self._storage.load_path(path)
ret.setdefault(path, {})[idx] = loads(properties)
return ret
async def importation(self,
connection,
properties):
await connection.execute("DELETE FROM property WHERE session_id = $1", self._storage.database_id)
for path, indexed_properties in properties.items():
path = self._storage.convert_path(path)
for index, property_ in indexed_properties.items():
index = self._storage.convert_index(index)
await connection.execute("INSERT INTO property(path, idx, properties, session_id) "
"VALUES ($1,$2,$3,$4)", path,
index,
dumps(property_),
self._storage.database_id)
def getconnection(self):
return self._storage.getconnection()
class Permissives:
__slots__ = ('_storage',)
def __init__(self,
storage):
self._storage = storage
# permissive
async def setpermissives(self,
connection,
path,
index,
permissive):
# log.debug('setpermissive %s %s %s %s', path, index, permissive, id(self))
index = self._storage.convert_index(index)
path = self._storage.convert_path(path)
await self.delpermissive(connection,
path,
index)
await connection.execute("INSERT INTO permissive(path, idx, permissives, session_id) "
"VALUES ($1,$2,$3,$4)", path,
index,
dumps(permissive),
self._storage.database_id)
async def getpermissives(self,
connection,
path,
index):
index = self._storage.convert_index(index)
path = self._storage.convert_path(path)
sql = 'SELECT permissives FROM permissive WHERE session_id = $1 AND path = $2 AND idx = $3'
params = [self._storage.database_id, path, index]
permissives = await connection.fetchval(sql,
*params)
if permissives is None:
return frozenset()
else:
return loads(permissives)
# log.debug('getpermissive %s %s %s', path, ret, id(self))
async def delpermissive(self,
connection,
path,
index):
index = self._storage.convert_index(index)
path = self._storage.convert_path(path)
sql = 'DELETE FROM permissive WHERE session_id = $1 AND path = $2 AND idx = $3'
params = [self._storage.database_id, path, index]
await connection.execute(sql, *params)
async def exportation(self,
connection):
"""return all modified permissives in a dictionary
example: {'path1': set(['perm1', 'perm2'])}
"""
ret = {}
sql = "SELECT path, idx, permissives FROM permissive WHERE session_id = $1"
for path, index, permissives in await connection.fetch(sql,
self._storage.database_id):
ret.setdefault(self._storage.load_path(path), {})[self._storage.load_index(index)] = loads(permissives)
return ret
async def importation(self,
connection,
permissives):
await connection.execute("DELETE FROM permissive WHERE session_id = $1", self._storage.database_id)
for path, indexed_permissives in permissives.items():
for index, permissive in indexed_permissives.items():
index = self._storage.convert_index(index)
path = self._storage.convert_path(path)
await connection.execute("INSERT INTO permissive(path, idx, permissives, session_id) "
"VALUES ($1,$2,$3,$4)", path,
index,
dumps(permissive),
self._storage.database_id)
def getconnection(self):
return self._storage.getconnection()

185
tiramisu/storage/postgres/storage.py
View file

@ -1,185 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright (C) 2020-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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 asyncpg import create_pool
from asyncpg.exceptions import UniqueViolationError
import warnings
from os.path import join
from typing import Optional, Dict
from ...i18n import _
from ...error import ConflictError
from ...asyncinit import asyncinit
class Setting:
""":param dsn: something like postgres://tiramisu:tiramisu@localhost:5432/tiramisu
"""
__slots__ = ('dsn',)
def __init__(self):
self.dsn = 'postgres://tiramisu:tiramisu@localhost:5432/tiramisu'
# FIXME
self.dsn = 'postgres:///tiramisu?host=/var/run/postgresql/&user=tiramisu'
def __setattr__(self, key, value):
if hasattr(self, key) and getattr(self, key) == value:
return
if POOL is not None: # pragma: no cover
raise Exception(_('cannot change setting when connexion is already '
'opened'))
super().__setattr__(key, value)
POOL = None
PERSISTENT = True
SETTING = Setting()
class Connection:
async def __aenter__(self):
self.connection = await POOL.acquire()
self.transaction = self.connection.transaction()
await self.transaction.__aenter__()
return self
async def __aexit__(self,
type,
value,
traceback):
await self.transaction.__aexit__(type,
value,
traceback)
await self.connection.close()
async def fetch(self,
*args):
return await self.connection.fetch(*args)
async def fetchrow(self,
*args):
return await self.connection.fetchrow(*args)
async def fetchval(self,
*args):
return await self.connection.fetchval(*args)
async def execute(self,
*args):
await self.connection.execute(*args)
async def list_sessions():
async with Connection() as connection:
return await _list_sessions(connection)
async def _list_sessions(connection):
return [row[0] for row in await connection.fetch("SELECT session FROM session")]
async def delete_session(session_id):
async with Connection() as connection:
database_id = await connection.fetchval("SELECT session_id FROM session WHERE session = $1", session_id)
if database_id is not None:
await _delete_session(database_id,
connection)
async def _delete_session(database_id,
connection):
await connection.execute('DELETE FROM property WHERE session_id = $1', database_id)
await connection.execute('DELETE FROM permissive WHERE session_id = $1', database_id)
await connection.execute('DELETE FROM value WHERE session_id = $1', database_id)
await connection.execute('DELETE FROM information WHERE session_id = $1', database_id)
await connection.execute('DELETE FROM session WHERE session_id = $1', database_id)
async def init():
# self.pool = await connect(dsn=SETTING.dsn)
global POOL
if POOL is None:
POOL = await create_pool(dsn=SETTING.dsn)
#print(' async with POOL.acquire() as connection:')
#print(' async with connection.transaction():')
sql = """
CREATE TABLE IF NOT EXISTS session(session_id SERIAL, session TEXT UNIQUE, PRIMARY KEY(session_id));
CREATE TABLE IF NOT EXISTS property(path TEXT, idx INTEGER, properties BYTEA, session_id INTEGER, PRIMARY KEY(path, idx, session_id), FOREIGN KEY(session_id) REFERENCES session(session_id));
CREATE TABLE IF NOT EXISTS permissive(path TEXT, idx INTEGER, permissives BYTEA, session_id INTEGER, PRIMARY KEY(path, idx, session_id), FOREIGN KEY(session_id) REFERENCES session(session_id));
CREATE TABLE IF NOT EXISTS value(path TEXT, value BYTEA, owner TEXT, idx INTEGER, session_id INTEGER, PRIMARY KEY (path, idx, session_id), FOREIGN KEY(session_id) REFERENCES session(session_id));
CREATE TABLE IF NOT EXISTS information(key TEXT, value BYTEA, session_id INTEGER, path TEXT, PRIMARY KEY (key, session_id), FOREIGN KEY(session_id) REFERENCES session(session_id));"""
#print(' await connection.execute("""'+sql+'""")')
await POOL.execute(sql)
@asyncinit
class Storage:
__slots__ = ('pool',
'database_id',
'session_id',
'created')
storage = 'postgres'
async def __init__(self,
connection: Connection,
session_id: str,
delete_old_session: bool) -> None:
if not isinstance(session_id, str):
raise ValueError(_('session_id has to be a string'))
self.database_id = None
self.session_id = session_id
select = await connection.fetchval("SELECT session_id FROM session WHERE session = $1",
self.session_id)
if select is not None:
if delete_old_session:
await self.delete_session()
else:
self.database_id = select
if self.database_id is None:
self.database_id = await connection.fetchval('INSERT INTO session(session) VALUES ($1) RETURNING session_id',
self.session_id)
def convert_index(self, index):
if index is None:
index = -1
return index
def convert_path(self, path):
if path is None:
path = '_none'
return path
def load_index(self, index):
if index == -1:
index = None
return index
def load_path(self, path):
if path == '_none':
path = None
return path
async def delete_session(self):
if self.database_id is not None:
await _delete_session(self.database_id,
POOL)
self.database_id = None
async def list_sessions(self,
connection):
return await _list_sessions(connection)
def getconnection(self):
return Connection()

314
tiramisu/storage/postgres/value.py
View file

@ -1,314 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright (C) 2020-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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/>.
# ____________________________________________________________
try:
from cPickle import loads, dumps
except ImportError:
from pickle import loads, dumps
from ...setting import undefined, owners
from ...i18n import _
from ...log import log
from .storage import delete_session
class Values:
__slots__ = ('__weakref__',
'_storage')
def __init__(self,
storage):
"""init plugin means create values storage
"""
self._storage = storage
# value
async def setvalue(self,
connection,
path,
value,
owner,
index,
new=False):
"""set value for an option
a specified value must be associated to an owner
"""
# log.debug('setvalue %s %s %s %s %s', path, value, owner, index, commit)
index = self._storage.convert_index(index)
path = self._storage.convert_path(path)
sql = 'INSERT INTO value(value, owner, session_id, path, idx) VALUES ($1,$2,$3,$4,$5)'
idx = self._storage.convert_index(index)
path = self._storage.convert_path(path)
params = [dumps(value), str(owner), self._storage.database_id, path, idx]
if new is False:
if index != -1:
await self.resetvalue_index(connection,
path,
index)
else:
await self.resetvalue(connection,
path)
await connection.execute(sql,
*params)
async def hasvalue(self,
connection,
path,
index=None):
"""if opt has a value
return: boolean
"""
# log.debug('hasvalue %s %s', path, index)
if index is not None:
index = self._storage.convert_index(index)
path = self._storage.convert_path(path)
request = "SELECT value FROM value WHERE path = $1 AND session_id = $2 AND idx = $3"
params = (path, self._storage.database_id, index)
else:
path = self._storage.convert_path(path)
request = "SELECT value FROM value WHERE path = $1 AND session_id = $2"
params = (path, self._storage.database_id)
ret = await connection.fetchrow(request, *params)
return ret is not None
async def reduce_index(self,
connection,
path,
index):
"""
_values == ((path1, path2), ((idx1_1, idx1_2), None),
((value1_1, value1_2), value2), ((owner1_1, owner1_2), owner2))
"""
# log.debug('reduce_index %s %s %s', path, index, id(self))
await connection.execute("UPDATE value SET idx = $1 WHERE path = $2 and idx = $3 "
"AND session_id = $4",
index - 1, path, index, self._storage.database_id)
async def resetvalue_index(self,
connection,
path,
index):
"""remove value means delete value in storage
"""
# log.debug('resetvalue_index %s %s', path, index)
await connection.execute("DELETE FROM value WHERE path = $1 AND session_id = $2 AND idx = $3",
path, self._storage.database_id, index)
await self.hasvalue(connection,
path,
index)
async def resetvalue(self,
connection,
path):
"""remove value means delete value in storage
"""
# log.debug('resetvalue %s', path)
await connection.execute("DELETE FROM value WHERE path = $1 AND session_id = $2",
path, self._storage.database_id)
# owner
async def setowner(self,
connection,
path,
owner,
index):
"""change owner for an option
"""
# log.debug('setowner %s %s %s', path, owner, index)
index = self._storage.convert_index(index)
path = self._storage.convert_path(path)
await connection.execute("UPDATE value SET owner = $1 WHERE path = $2 and idx = $3 AND session_id = $4",
str(owner), path, index, self._storage.database_id)
async def getowner(self,
connection,
path,
default,
index,
with_value=False):
"""get owner for an option
return: owner object
"""
# log.debug('getowner %s %s %s %s', path, default, index, with_value)
path = self._storage.convert_path(path)
index = self._storage.convert_index(index)
request = "SELECT owner, value FROM value WHERE session_id = $1 AND path = $2 AND idx = $3"
params = [self._storage.database_id, path, index]
owner = await connection.fetchrow(request, *params)
if owner is None:
if not with_value:
return default
return default, None
# autocreate owners
try:
nowner = getattr(owners, owner[0])
except AttributeError: # pragma: no cover
owners.addowner(owner[0])
nowner = getattr(owners, owner[0])
if not with_value:
return nowner
value = loads(owner[1])
return nowner, value
async def set_information(self,
connection,
path,
key,
value):
"""updates the information's attribute
(which is a dictionary)
:param key: information's key (ex: "help", "doc"
:param value: information's value (ex: "the help string")
"""
# log.debug('set_information %s %s', key, value)
path = self._storage.convert_path(path)
await connection.execute("DELETE FROM information WHERE key = $1 AND session_id = $2 AND path = $3",
key, self._storage.database_id, path)
await connection.execute("INSERT INTO information(key, value, session_id, path) VALUES "
"($1, $2, $3, $4)", key, dumps(value), self._storage.database_id, path)
async def get_information(self,
connection,
path,
key,
):
"""retrieves one information's item
:param key: the item string (ex: "help")
"""
# log.debug('get_information %s %s', key, default)
path = self._storage.convert_path(path)
value = await connection.fetchval("SELECT value FROM information WHERE key = $1 AND "
"session_id = $2 AND path = $3",
key, self._storage.database_id, path)
if value is None:
raise KeyError()
return loads(value)
async def del_information(self,
connection,
path,
key,
raises):
# log.debug('del_information %s %s', key, raises)
path = self._storage.convert_path(path)
information = await connection.fetchval("SELECT value FROM information WHERE key = $1 "
"AND session_id = $2 AND path = $3",
key, self._storage.database_id, path)
if raises and information is None:
raise ValueError(_("information's item not found {0}").format(key))
await connection.execute("DELETE FROM information WHERE key = $1 AND session_id = $2 AND path = $3",
key, self._storage.database_id, path)
async def list_information(self,
connection,
path):
path = self._storage.convert_path(path)
return [row[0] for row in await connection.fetch("SELECT key FROM information WHERE session_id = $1 AND path = $2",
self._storage.database_id, path)]
async def del_informations(self,
connection):
await connection.execute("DELETE FROM information WHERE session_id = $1",
self._storage.database_id)
async def exportation_informations(self,
connection,
):
informations = {}
for path, key, value in await connection.fetch("SELECT path, key, value FROM information WHERE session_id = $1", self._storage.database_id):
path = self._storage.load_path(path)
informations.setdefault(path, {})[key] = loads(value)
return informations
async def importation_informations(self,
connection,
informations,
):
await self.del_informations(connection)
for path, path_infos in informations.items():
path = self._storage.convert_path(path)
for key, value in path_infos.items():
await connection.execute("INSERT INTO information(key, value, session_id, path) VALUES "
"($1, $2, $3, $4)", key, dumps(value), self._storage.database_id, path)
async def exportation(self,
connection):
# log.debug('exportation')
ret = [[], [], [], []]
rows = await connection.fetch("SELECT path, value, owner, idx FROM value WHERE "
"session_id = $1", self._storage.database_id)
for row in rows:
path = self._storage.load_path(row[0])
value = loads(row[1])
owner = row[2]
index = self._storage.load_index(row[3])
if index is None:
ret[0].append(path)
ret[1].append(index)
ret[2].append(value)
ret[3].append(owner)
else:
if path in ret[0]:
path_idx = ret[0].index(path)
ret[1][path_idx].append(index)
ret[2][path_idx].append(value)
ret[3][path_idx].append(owner)
else:
ret[0].append(path)
ret[1].append([index])
ret[2].append([value])
ret[3].append([owner])
return ret
async def importation(self,
connection,
export):
# log.debug('importation')
request = "DELETE FROM value WHERE session_id = $1"
await connection.execute(request, self._storage.database_id)
for idx, path in enumerate(export[0]):
path = self._storage.convert_path(path)
index = self._storage.convert_index(export[1][idx])
value = export[2][idx]
owner = export[3][idx]
if index == -1:
await connection.execute("INSERT INTO value(path, value, owner, idx, session_id) VALUES "
"($1, $2, $3, $4, $5)", path, dumps(value),
str(owner), index,
self._storage.database_id)
else:
for val in zip(index, value, owner):
await connection.execute("INSERT INTO value(path, value, owner, idx, session_id)"
"VALUES ($1, $2, $3, $4, $5)", path,
dumps(val[1]),
str(val[2]), val[0],
self._storage.database_id)
async def get_max_length(self,
connection,
path):
# log.debug('get_max_length %s', path)
val_max = await connection.fetchval("SELECT max(idx) FROM value WHERE path = $1 AND session_id = $2",
path, self._storage.database_id)
if val_max is None:
return 0
return val_max + 1
def getconnection(self):
return self._storage.getconnection()

32
tiramisu/storage/sqlite3/__init__.py
View file

@ -1,32 +0,0 @@
# -*- coding: utf-8 -*-
# Copyright (C) 2013-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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/>.
# ____________________________________________________________
"""Sqlite3 plugin for storage.
"""
from .value import Values
from .setting import Properties, Permissives
from .storage import PERSISTENT, SETTING, Storage, list_sessions, init, Connection
__all__ = ('PERSISTENT',
'SETTING',
'Values',
'Properties',
'Permissives',
'Storage',
'init',
'Connection',
'list_sessions')

199
tiramisu/storage/sqlite3/setting.py
View file

@ -1,199 +0,0 @@
# -*- coding: utf-8 -*-
"default plugin for setting: set it in a simple dictionary"
# Copyright (C) 2013-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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 .sqlite3db import Sqlite3DB
from ...log import log
class Properties(Sqlite3DB):
__slots__ = tuple()
def __init__(self, storage):
super(Properties, self).__init__(storage)
# properties
async def setproperties(self,
connection,
path,
index,
properties):
await self.delproperties(connection,
path,
index)
await connection.execute("INSERT INTO property(path, tiram_index, properties, session_id) VALUES "
"(?, ?, ?, ?)", (path,
index,
self._sqlite_encode(properties),
self._session_id))
async def getproperties(self,
connection,
path,
index,
default_properties):
sql = 'SELECT properties FROM property WHERE session_id = ? '
params = [self._session_id]
if path is None:
sql += "AND path is NULL "
else:
sql += "AND path = ? "
params.append(path)
if index is None:
sql += "AND tiram_index is NULL LIMIT 1"
else:
sql += "AND tiram_index = ? LIMIT 1"
params.append(index)
value = await connection.select(sql, params)
if value is None:
return set(default_properties)
else:
return set(self._sqlite_decode(value[0]))
async def delproperties(self,
connection,
path,
index):
sql = 'DELETE FROM property WHERE session_id = ? '
params = [self._session_id]
if path is None:
sql += 'AND path is NULL '
else:
sql += 'AND path = ? '
params.append(path)
if index is None:
sql += 'AND tiram_index is NULL'
else:
params.append(index)
sql += 'AND tiram_index = ?'
await connection.execute(sql, params)
async def exportation(self,
connection):
"""return all modified settings in a dictionary
example: {'path1': set(['prop1', 'prop2'])}
"""
ret = {}
for path, tiram_index, properties, _ in await connection.select("SELECT * FROM property "
"WHERE session_id = ?",
(self._session_id,),
only_one=False):
ret.setdefault(path, {})[tiram_index] = self._sqlite_decode(properties)
return ret
async def importation(self,
connection,
properties):
await connection.execute("DELETE FROM property WHERE session_id = ?", (self._session_id,))
for path, indexed_properties in properties.items():
for index, property_ in indexed_properties.items():
await connection.execute("INSERT INTO property(path, tiram_index, properties, session_id) "
"VALUES (?, ?, ?, ?)", (path,
index,
self._sqlite_encode(property_),
self._session_id,
))
def getconnection(self):
return self._storage.getconnection()
class Permissives(Sqlite3DB):
__slots__ = tuple()
# permissive
async def setpermissives(self,
connection,
path,
index,
permissive):
log.debug('setpermissive %s %s %s %s', path, index, permissive, id(self))
await self.delpermissive(connection,
path,
index)
await connection.execute("INSERT INTO permissive(path, tiram_index, permissives, session_id) "
"VALUES (?, ?, ?, ?)", (path,
index,
self._sqlite_encode(permissive),
self._session_id))
async def getpermissives(self,
connection,
path,
index):
sql = 'SELECT permissives FROM permissive WHERE session_id = ? '
params = [self._session_id]
if path is None:
sql += "AND path is NULL "
else:
sql += "AND path = ? "
params.append(path)
if index is None:
sql += "AND tiram_index is NULL LIMIT 1"
else:
sql += "AND tiram_index = ? LIMIT 1"
params.append(index)
permissives = await connection.select(sql, params)
if permissives is None:
ret = frozenset()
else:
ret = frozenset(self._sqlite_decode(permissives[0]))
log.debug('getpermissive %s %s %s', path, ret, id(self))
return ret
async def delpermissive(self,
connection,
path,
index):
sql = 'DELETE FROM permissive WHERE session_id = ? '
params = [self._session_id]
if path is None:
sql += 'AND path is NULL '
else:
sql += 'AND path = ? '
params.append(path)
if index is None:
sql += 'AND tiram_index is NULL'
else:
params.append(index)
sql += 'AND tiram_index = ?'
await connection.execute(sql, params)
async def exportation(self,
connection):
"""return all modified permissives in a dictionary
example: {'path1': set(['perm1', 'perm2'])}
"""
ret = {}
sql = "SELECT path, tiram_index, permissives FROM permissive WHERE session_id = ?"
for path, index, permissives in await connection.select(sql,
(self._session_id,),
only_one=False):
ret.setdefault(path, {})[index] = self._sqlite_decode(permissives)
return ret
async def importation(self,
connection,
permissives):
await connection.execute("DELETE FROM permissive WHERE session_id = ?", (self._session_id,))
for path, indexed_permissives in permissives.items():
for index, permissive in indexed_permissives.items():
await connection.execute("INSERT INTO permissive(path, tiram_index, permissives, session_id) "
"VALUES (?, ?, ?, ?)", (path,
index,
self._sqlite_encode(permissive),
self._session_id,
))

49
tiramisu/storage/sqlite3/sqlite3db.py
View file

@ -1,49 +0,0 @@
# -*- coding: utf-8 -*-
"sqlite3"
# Copyright (C) 2013-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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/>.
# ____________________________________________________________
try:
from cPickle import loads, dumps
except ImportError:
from pickle import loads, dumps
class Sqlite3DB:
__slots__ = ('_session_id',
'_storage')
def __init__(self, storage):
self._session_id = storage.session_id
self._storage = storage
def _sqlite_decode_path(self, path):
if path == '_none':
return None
else:
return path
def _sqlite_encode_path(self, path):
if path is None:
return '_none'
else:
return path
def _sqlite_decode(self, value):
return loads(value)
def _sqlite_encode(self, value):
if isinstance(value, tuple):
value = list(value)
return dumps(value)

201
tiramisu/storage/sqlite3/storage.py
View file

@ -1,201 +0,0 @@
# -*- coding: utf-8 -*-
" with sqlite3 engine"
# Copyright (C) 2013-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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/>.
# ____________________________________________________________
import sqlite3
import warnings
from os.path import join
from typing import Optional, Dict
from ...i18n import _
from ...error import ConflictError
from ...asyncinit import asyncinit
global CONN
CONN = None
async def init():
global CONN
if CONN is None:
CONN = sqlite3.connect(_gen_filename())
CONN.text_factory = str
session_table = 'CREATE TABLE IF NOT EXISTS session(session_id INTEGER, session TEXT UNIQUE, PRIMARY KEY(session_id))'
settings_table = 'CREATE TABLE IF NOT EXISTS property(path TEXT, tiram_index INTEGER, properties TEXT, session_id INTEGER, PRIMARY KEY(path, tiram_index, session_id), ' \
'FOREIGN KEY(session_id) REFERENCES session(session_id))'
permissives_table = 'CREATE TABLE IF NOT EXISTS permissive(path TEXT, tiram_index INTEGER, permissives TEXT, session_id INTEGER, ' \
'PRIMARY KEY(path, tiram_index, session_id), ' \
'FOREIGN KEY(session_id) REFERENCES session(session_id))'
values_table = 'CREATE TABLE IF NOT EXISTS value(path TEXT, value TEXT, owner TEXT, idx INTEGER, session_id INTEGER, ' \
'PRIMARY KEY (path, idx, session_id), ' \
'FOREIGN KEY(session_id) REFERENCES session(session_id))'
informations_table = 'CREATE TABLE IF NOT EXISTS information(key TEXT, value TEXT, session_id INTEGER, path TEXT, ' \
'PRIMARY KEY (key, session_id), ' \
'FOREIGN KEY(session_id) REFERENCES session(session_id))'
cursor = CONN.cursor()
cursor.execute(session_table)
cursor.execute(values_table)
cursor.execute(informations_table)
cursor.execute(settings_table)
cursor.execute(permissives_table)
CONN.commit()
class Connection:
async def __aenter__(self):
self.connection = CONN.cursor()
return self
async def __aexit__(self,
type,
value,
traceback):
if type is None:
CONN.commit()
else:
CONN.rollback()
self.connection.close()
async def execute(self,
sql: str,
params: Optional[Dict]=None) -> None:
if params is None:
params = tuple()
self.connection.execute(sql, params)
async def select(self,
sql: str,
params: Optional[Dict]=None,
only_one: bool=True) -> 'Row':
if params is None:
params = tuple()
self.connection.execute(sql, params)
if only_one:
return self.connection.fetchone()
else:
return self.connection.fetchall()
class Setting:
""":param extension: database file extension (by default: db)
:param dir_database: root database directory (by default: /tmp)
"""
__slots__ = ('extension',
'dir_database',
'name')
def __init__(self):
self.extension = 'db'
self.dir_database = '/tmp'
self.name = 'tiramisu'
def __setattr__(self, key, value):
if CONN is not None: # pragma: no cover
raise Exception(_('cannot change setting when connexion is already '
'opened'))
super().__setattr__(key, value)
PERSISTENT = True
SETTING = Setting()
def _gen_filename():
return join(SETTING.dir_database, '{0}.{1}'.format(SETTING.name, SETTING.extension))
async def list_sessions():
if not CONN:
warnings.warn_explicit(Warning(_('Cannot list sessions, please connect to database first')),
category=Warning,
filename=__file__,
lineno=63)
return []
cursor = CONN.cursor()
return await _list_sessions(cursor)
async def _list_sessions(cursor):
names = [row[0] for row in cursor.execute("SELECT session FROM session").fetchall()]
return names
async def delete_session(session_id):
cursor = CONN.cursor()
ret = cursor.execute("SELECT session_id FROM session WHERE session = ?",
(session_id,)).fetchone()
if ret is not None:
database_id = ret[0]
await _delete_session(database_id,
cursor)
cursor.close()
async def _delete_session(database_id,
cursor):
cursor.execute("DELETE FROM property WHERE session_id = ?", (database_id,))
cursor.execute("DELETE FROM permissive WHERE session_id = ?", (database_id,))
cursor.execute("DELETE FROM value WHERE session_id = ?", (database_id,))
cursor.execute("DELETE FROM information WHERE session_id = ?", (database_id,))
cursor.execute("DELETE FROM session WHERE session_id = ?", (database_id,))
CONN.commit()
@asyncinit
class Storage:
__slots__ = ('_conn',
'_cursor',
'session_id',
'session_name',
'created')
storage = 'sqlite3'
async def __init__(self,
connection: Connection,
session_id: str,
delete_old_session: bool) -> None:
if not isinstance(session_id, str):
raise ValueError(_('session_id has to be a string'))
self.created = False
self.session_id = None
self.session_name = session_id
select = await connection.select("SELECT session_id FROM session WHERE session = ?", (session_id,))
if select is not None:
if delete_old_session:
self.delete_session()
else:
self.session_id = select[0]
if self.session_id is None:
await connection.execute('INSERT INTO session(session) VALUES (?)',
(session_id,))
self.session_id = connection.connection.lastrowid
self.created = True
async def delete_session(self):
if self.session_id is not None:
await _delete_session(self.session_id,
CONN)
self.session_id = None
async def list_sessions(self):
return await _list_sessions(self._cursor)
def getconnection(self):
return Connection()
def getsession():
pass

315
tiramisu/storage/sqlite3/value.py
View file

@ -1,315 +0,0 @@
# -*- coding: utf-8 -*-
"default plugin for value: set it in a simple dictionary"
# Copyright (C) 2013-2023 Team tiramisu (see AUTHORS for all contributors)
#
# This program is free software: you can redistribute it and/or modify it
# under the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or (at your
# option) any later version.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# 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 .sqlite3db import Sqlite3DB
from .storage import delete_session
from ...setting import undefined, owners
from ...i18n import _
from ...log import log
class Values(Sqlite3DB):
__slots__ = ('__weakref__',)
def __init__(self, storage):
"""init plugin means create values storage
"""
super(Values, self).__init__(storage)
# sqlite
async def _sqlite_select(self,
connection,
path,
index):
request = "SELECT value FROM value WHERE path = ? AND session_id = ? "
params = (path, self._session_id)
if index is not None:
request += "and idx = ? "
params = (path, self._session_id, index)
request += "LIMIT 1"
return await connection.select(request, params)
# value
async def setvalue(self,
connection,
path,
value,
owner,
index,
new=False):
"""set value for an option
a specified value must be associated to an owner
"""
log.debug('setvalue %s %s %s %s', path, value, owner, index)
path = self._sqlite_encode_path(path)
if index is not None:
if not new:
await self.resetvalue_index(connection,
path,
index)
await connection.execute("INSERT INTO value(path, value, owner, idx, session_id) VALUES "
"(?, ?, ?, ?, ?)", (path, self._sqlite_encode(value),
str(owner),
index,
self._session_id))
else:
if not new:
await self.resetvalue(connection,
path)
await connection.execute("INSERT INTO value(path, value, owner, session_id) VALUES "
"(?, ?, ?, ?)", (path, self._sqlite_encode(value),
str(owner),
self._session_id))
async def hasvalue(self,
connection,
path,
index=None):
"""if opt has a value
return: boolean
"""
log.debug('hasvalue %s %s', path, index)
path = self._sqlite_encode_path(path)
return await self._sqlite_select(connection,
path,
index) is not None
async def reduce_index(self,
connection,
path,
index):
"""
_values == ((path1, path2), ((idx1_1, idx1_2), None),
((value1_1, value1_2), value2), ((owner1_1, owner1_2), owner2))
"""
log.debug('reduce_index %s %s %s', path, index, id(self))
await connection.execute("UPDATE value SET idx = ? WHERE path = ? and idx = ? "
"AND session_id = ?",
(index - 1, path, index, self._session_id))
async def resetvalue_index(self,
connection,
path,
index):
"""remove value means delete value in storage
"""
log.debug('resetvalue_index %s %s', path, index)
path = self._sqlite_encode_path(path)
await connection.execute("DELETE FROM value WHERE path = ? AND session_id = ? AND idx = ?",
(path, self._session_id, index))
async def resetvalue(self,
connection,
path):
"""remove value means delete value in storage
"""
log.debug('resetvalue %s', path)
path = self._sqlite_encode_path(path)
await connection.execute("DELETE FROM value WHERE path = ? AND session_id = ?",
(path, self._session_id))
# owner
async def setowner(self,
connection,
path,
owner,
index=None):
"""change owner for an option
"""
log.debug('setowner %s %s %s', path, owner, index)
path = self._sqlite_encode_path(path)
if index is None:
await connection.execute("UPDATE value SET owner = ? WHERE path = ? AND session_id = ?",
(str(owner), path, self._session_id))
else:
await connection.execute("UPDATE value SET owner = ? WHERE path = ? and idx = ? AND session_id = ?",
(str(owner), path, index, self._session_id))
async def getowner(self,
connection,
path,
default,
index=None,
with_value=False):
"""get owner for an option
return: owner object
"""
log.debug('getowner %s %s %s %s', path, default, index, with_value)
path = self._sqlite_encode_path(path)
request = "SELECT owner, value FROM value WHERE path = ? AND session_id = ?"
if index is not None:
request += " AND idx = ?"
params = (path, self._session_id, index)
else:
params = (path, self._session_id)
request += ' LIMIT 1'
owner = await connection.select(request, params)
if owner is None:
if not with_value:
return default
else:
return default, None
else:
# autocreate owners
try:
nowner = getattr(owners, owner[0])
except AttributeError: # pragma: no cover
owners.addowner(owner[0])
nowner = getattr(owners, owner[0])
if not with_value:
return nowner
else:
value = self._sqlite_decode(owner[1])
return nowner, value
async def set_information(self,
connection,
path,
key,
value):
"""updates the information's attribute
(which is a dictionary)
:param key: information's key (ex: "help", "doc"
:param value: information's value (ex: "the help string")
"""
log.debug('set_information %s %s', key, value)
path = self._sqlite_encode_path(path)
await connection.execute("DELETE FROM information WHERE key = ? AND session_id = ? AND path = ?",
(key, self._session_id, path))
await connection.execute("INSERT INTO information(key, value, session_id, path) VALUES "
"(?, ?, ?, ?)", (key, self._sqlite_encode(value), self._session_id, path))
async def get_information(self,
connection,
path,
key,
default):
"""retrieves one information's item
:param key: the item string (ex: "help")
"""
log.debug('get_information %s %s', key, default)
path = self._sqlite_encode_path(path)
value = await connection.select("SELECT value FROM information WHERE key = ? AND "
"session_id = ? AND path = ?",
(key, self._session_id, path))
if value is None:
if default is undefined:
raise ValueError(_("information's item"
" not found: {0}").format(key))
return default
else:
return self._sqlite_decode(value[0])
async def del_information(self,
connection,
path,
key,
raises):
log.debug('del_information %s %s', key, raises)
path = self._sqlite_encode_path(path)
information = await connection.select("SELECT value FROM information WHERE key = ? "
"AND session_id = ? AND path = ?",
(key, self._session_id, path))
if raises and information is None:
raise ValueError(_("information's item not found {0}").format(key))
await connection.execute("DELETE FROM information WHERE key = ? AND session_id = ? AND path = ?",
(key, self._session_id, path))
async def list_information(self,
connection,
path):
path = self._sqlite_encode_path(path)
rows = await connection.select("SELECT key FROM information WHERE session_id = ? AND path = ?",
(self._session_id, path),
only_one=False)
ret = []
for row in rows:
ret.append(self._sqlite_decode_path(row[0]))
return ret
async def del_informations(self,
connection):
await connection.execute("DELETE FROM information WHERE session_id = ?",
(self._session_id,))
async def exportation(self,
connection):
log.debug('exportation')
rows = await connection.select("SELECT path, value, owner, idx FROM value WHERE "
"session_id = ?;", (self._session_id,), only_one=False)
ret = [[], [], [], []]
for row in rows:
path = self._sqlite_decode_path(row[0])
value = self._sqlite_decode(row[1])
owner = row[2]
index = row[3]
if index is None:
ret[0].append(path)
ret[1].append(index)
ret[2].append(value)
ret[3].append(owner)
else:
if path in ret[0]:
path_idx = ret[0].index(path)
ret[1][path_idx].append(index)
ret[2][path_idx].append(value)
ret[3][path_idx].append(owner)
else:
ret[0].append(path)
ret[1].append([index])
ret[2].append([value])
ret[3].append([owner])
return ret
async def importation(self,
connection,
export):
log.debug('importation')
request = "DELETE FROM value WHERE session_id = ?"
await connection.execute(request, (self._session_id,))
for idx, path in enumerate(export[0]):
path = self._sqlite_encode_path(path)
index = export[1][idx]
value = export[2][idx]
owner = export[3][idx]
if index is None:
await connection.execute("INSERT INTO value(path, value, owner, idx, session_id) VALUES "
"(?, ?, ?, ?, ?)", (path, self._sqlite_encode(value),
str(owner), index,
self._session_id))
else:
for val in zip(index, value, owner):
await connection.execute("INSERT INTO value(path, value, owner, idx, session_id)"
"VALUES (?, ?, ?, ?, ?)", (path,
self._sqlite_encode(val[1]),
str(val[2]), val[0],
self._session_id))
async def get_max_length(self,
connection,
path):
log.debug('get_max_length %s', path)
val_max = await connection.select("SELECT max(idx) FROM value WHERE path = ? AND session_id = ?",
(path, self._session_id), False)
if val_max[0][0] is None:
return 0
return val_max[0][0] + 1

316
tiramisu/todict.py
View file

@ -43,36 +43,36 @@ class Callbacks(object):
self.remotable = tiramisu_web.remotable
self.callbacks = []
async def add(self,
def add(self,
path,
childapi,
schema,
force_store_value):
if self.remotable == 'all' or await childapi.option.isoptiondescription():
if self.remotable == 'all' or childapi.option.isoptiondescription():
return
callback, callback_params = await childapi.option.callbacks()
if callback is None: # FIXME ? and force_store_value and self.clearable != 'all':
return
self.callbacks.append((callback, callback_params, path, childapi, schema, force_store_value))
# callback, callback_params = childapi.option.callbacks()
# if callback is None: # FIXME ? and force_store_value and self.clearable != 'all':
# return
# self.callbacks.append((callback, callback_params, path, childapi, schema, force_store_value))
async def process_properties(self, form):
def process_properties(self, form):
for callback, callback_params, path, childapi, schema, force_store_value in self.callbacks:
if await childapi.option.isfollower():
await self.tiramisu_web.set_remotable(path, form, childapi)
if childapi.option.isfollower():
self.tiramisu_web.set_remotable(path, form, childapi)
continue
has_option = False
if callback_params is not None:
for callback_param in chain(callback_params.args, callback_params.kwargs.values()):
if isinstance(callback_param, ParamOption):
has_option = True
if 'expire' in await childapi.option.properties():
await self.tiramisu_web.set_remotable(callback_param.option.impl_getpath(), form)
if 'expire' in childapi.option.properties():
self.tiramisu_web.set_remotable(callback_param.option.impl_getpath(), form)
if not has_option and form.get(path, {}).get('remote', False) == False:
if 'expire' in await childapi.option.properties():
await self.tiramisu_web.set_remotable(path, form, childapi)
elif await childapi.owner.isdefault():
if 'expire' in childapi.option.properties():
self.tiramisu_web.set_remotable(path, form, childapi)
elif childapi.owner.isdefault():
# get calculated value and set clearable
schema[path]['value'] = await childapi.value.get()
schema[path]['value'] = childapi.value.get()
if self.clearable == 'minimum':
form.setdefault(path, {})['clearable'] = True
@ -87,9 +87,9 @@ class Callbacks(object):
# form.setdefault(opt_path, {})
# form[opt_path].setdefault('copy', []).append(path)
async def process(self,
def process(self,
form):
await self.process_properties(form)
self.process_properties(form)
self.manage_callbacks(form)
@ -98,10 +98,10 @@ class Consistencies(object):
self.not_equal = {}
self.tiramisu_web = tiramisu_web
async def add(self, path, childapi, form):
def add(self, path, childapi, form):
return
if not await childapi.option.isoptiondescription():
for consistency in await childapi.option.consistencies():
if not childapi.option.isoptiondescription():
for consistency in childapi.option.consistencies():
cons_id, func, all_cons_opts, params = consistency
if func == '_cons_not_equal' and params.get('transitive', True) is True:
options_path = []
@ -115,9 +115,9 @@ class Consistencies(object):
self.not_equal.setdefault(option._path, {}).setdefault(warnings_only, []).extend(paths)
else:
for option in all_cons_opts:
await self.tiramisu_web.set_remotable(option()._path, form)
self.tiramisu_web.set_remotable(option()._path, form)
async def process(self, form):
def process(self, form):
for path in self.not_equal:
if self.tiramisu_web.is_remote(path, form):
continue
@ -140,23 +140,23 @@ class Requires(object):
self.tiramisu_web = tiramisu_web
self.action_hide = self.tiramisu_web.config._config_bag.properties
async def set_master_remote(self, childapi, path, form):
if await childapi.option.isoptiondescription():
def set_master_remote(self, childapi, path, form):
if childapi.option.isoptiondescription():
isfollower = False
else:
isfollower = await childapi.option.isfollower()
isfollower = childapi.option.isfollower()
if isfollower:
parent_path = path.rsplit('.', 1)[0]
parent = await self.tiramisu_web.config.unrestraint.option(parent_path)
leader = await parent.list()[0]
await self.tiramisu_web.set_remotable(await leader.option.path(), form, leader)
parent = self.tiramisu_web.config.unrestraint.option(parent_path)
leader = parent.list()[0]
self.tiramisu_web.set_remotable(leader.option.path(), form, leader)
async def manage_requires(self,
def manage_requires(self,
childapi,
path,
form,
current_action):
for requires in await childapi.option.properties(uncalculated=True):
for requires in childapi.option.properties(uncalculated=True):
if not isinstance(requires, str):
option = requires.params.kwargs['condition'].option
expected = [requires.params.kwargs['expected'].value]
@ -178,8 +178,8 @@ class Requires(object):
if isinstance(option, tuple):
for option_param in chain(option[1].args, option[1].kwargs.values()):
if isinstance(option_param, ParamOption):
await self.tiramisu_web.set_remotable(option_param.option.impl_getpath(), form)
await self.set_master_remote(childapi, path, form)
self.tiramisu_web.set_remotable(option_param.option.impl_getpath(), form)
self.set_master_remote(childapi, path, form)
# elif len_to_long:
# self.tiramisu_web.set_remotable(option.impl_getpath(), form)
# self.set_master_remote(childapi, path, form)
@ -191,8 +191,8 @@ class Requires(object):
# transitive to "False" not supported yet for a requirement
# same_action to "False" not supported yet for a requirement
# operator "and" not supported yet for a requirement
await self.tiramisu_web.set_remotable(option_path, form, require_option)
await self.set_master_remote(childapi, path, form)
self.tiramisu_web.set_remotable(option_path, form, require_option)
self.set_master_remote(childapi, path, form)
# if require_option.option.requires():
# for reqs in require_option.option.requires():
# for req in reqs:
@ -208,10 +208,10 @@ class Requires(object):
inv_act = 'show'
if option.get_type() == 'choice':
require_option = self.tiramisu_web.config.unrestraint.option(option_path)
values = await self.tiramisu_web.get_enum(require_option,
await require_option.option.ismulti(),
values = self.tiramisu_web.get_enum(require_option,
require_option.option.ismulti(),
option_path,
await require_option.option.properties())
require_option.option.properties())
for value in values:
if value not in expected:
self.requires.setdefault(path,
@ -222,8 +222,8 @@ class Requires(object):
if current_action is None:
current_action = action
elif current_action != action:
await self.tiramisu_web.set_remotable(option_path, form)
await self.set_master_remote(childapi, path, form)
self.tiramisu_web.set_remotable(option_path, form)
self.set_master_remote(childapi, path, form)
for exp in expected:
self.requires.setdefault(path,
{'expected': {}}
@ -232,29 +232,29 @@ class Requires(object):
[]).append(option_path)
self.requires[path].setdefault('default', {}).setdefault(inv_act, []).append(option_path)
else:
await self.tiramisu_web.set_remotable(option_path, form)
await self.set_master_remote(childapi, path, form)
self.tiramisu_web.set_remotable(option_path, form)
self.set_master_remote(childapi, path, form)
async def add(self, path, childapi, form):
def add(self, path, childapi, form):
#collect id of all options
child = await childapi.option.get()
child = childapi.option.get()
if isinstance(child, SynDynOption):
child = child.opt
self.options[child] = path
current_action = None
await self.manage_requires(childapi,
self.manage_requires(childapi,
path,
form,
current_action)
async def process(self, form):
def process(self, form):
dependencies = {}
for path, values in self.requires.items():
if 'default' in values:
for option in values['default'].get('show', []):
if path == option:
await self.tiramisu_web.set_remotable(path, form)
self.tiramisu_web.set_remotable(path, form)
if not self.tiramisu_web.is_remote(option, form):
dependencies.setdefault(option,
{'default': {}, 'expected': {}}
@ -263,7 +263,7 @@ class Requires(object):
dependencies[option]['default']['show'].append(path)
for option in values['default'].get('hide', []):
if path == option:
await self.tiramisu_web.set_remotable(path, form)
self.tiramisu_web.set_remotable(path, form)
if not self.tiramisu_web.is_remote(option, form):
dependencies.setdefault(option,
{'default': {}, 'expected': {}}
@ -275,7 +275,7 @@ class Requires(object):
expected = ''
for option in actions.get('show', []):
if path == option:
await self.tiramisu_web.set_remotable(path, form)
self.tiramisu_web.set_remotable(path, form)
if not self.tiramisu_web.is_remote(option, form):
dependencies.setdefault(option,
{'expected': {}}
@ -285,7 +285,7 @@ class Requires(object):
dependencies[option]['expected'][expected]['show'].append(path)
for option in actions.get('hide', []):
if path == option:
await self.tiramisu_web.set_remotable(path, form)
self.tiramisu_web.set_remotable(path, form)
if not self.tiramisu_web.is_remote(option, form):
dependencies.setdefault(option,
{'expected': {}}
@ -328,17 +328,17 @@ class TiramisuDict:
#all, minimum, none
self.remotable = remotable
async def add_help(self,
def add_help(self,
obj,
childapi):
hlp = await childapi.information.get('help', None)
hlp = childapi.information.get('help', None)
if hlp is not None:
obj['help'] = hlp
async def get_list(self, root, subchildapi):
def get_list(self, root, subchildapi):
ret = []
for childapi in await subchildapi.list('all'):
childname = await childapi.option.name()
for childapi in subchildapi.list('all'):
childname = childapi.option.name()
if root is None:
path = childname
else:
@ -352,19 +352,19 @@ class TiramisuDict:
else:
return path in form and form[path].get('remote', False) == True
async def set_remotable(self, path, form, childapi=None):
def set_remotable(self, path, form, childapi=None):
if self.remotable == 'none':
raise ValueError(_('option {} only works when remotable is not "none"').format(path))
form.setdefault(path, {})['remote'] = True
if childapi is None:
childapi = self.config.unrestraint.option(path)
if await childapi.option.isfollower():
if childapi.option.isfollower():
parent_path = path.rsplit('.', 1)[0]
parent = await self.config.unrestraint.option(parent_path)
leader = await parent.list()[0]
form.setdefault(await leader.option.path(), {})['remote'] = True
parent = self.config.unrestraint.option(parent_path)
leader = parent.list()[0]
form.setdefault(leader.option.path(), {})['remote'] = True
async def walk(self,
def walk(self,
root,
subchildapi,
schema,
@ -389,36 +389,36 @@ class TiramisuDict:
subchildapi = self.config.unrestraint.option(root)
isleadership = False
else:
isleadership = await subchildapi.option.isleadership()
isleadership = subchildapi.option.isleadership()
leader_len = None
for path, childapi in await self.get_list(root, subchildapi):
for path, childapi in self.get_list(root, subchildapi):
if isleadership and leader_len is None:
leader_len = await childapi.value.len()
leader_len = childapi.value.len()
one_is_remote = False
props_no_requires = set(await childapi.option.properties())
props_no_requires = set(childapi.option.properties())
if form is not None:
await self.requires.add(path,
self.requires.add(path,
childapi,
form)
await self.consistencies.add(path,
self.consistencies.add(path,
childapi,
form)
await self.callbacks.add(path,
self.callbacks.add(path,
childapi,
schema,
'force_store_value' in props_no_requires)
childapi_option = childapi.option
if model is not None and await childapi.option.isoptiondescription() or not await childapi_option.issymlinkoption():
await self.gen_model(model,
if model is not None and childapi.option.isoptiondescription() or not childapi_option.issymlinkoption():
self.gen_model(model,
childapi,
path,
leader_len,
updates_status)
if order is not None:
order.append(path)
if await childapi.option.isoptiondescription():
if childapi.option.isoptiondescription():
web_type = 'optiondescription'
if await childapi_option.isleadership():
if childapi_option.isleadership():
type_ = 'array'
else:
type_ = 'object'
@ -428,7 +428,7 @@ class TiramisuDict:
subschema = schema[path]['properties']
else:
subschema = schema
await self.walk(path,
self.walk(path,
childapi,
subschema,
model,
@ -436,31 +436,31 @@ class TiramisuDict:
order,
updates_status)
else:
child = await childapi_option.get()
child = childapi_option.get()
childtype = child.__class__.__name__
if childtype == 'SynDynOption':
childtype = child.opt.__class__.__name__
if await childapi_option.issymlinkoption():
if childapi_option.issymlinkoption():
web_type = 'symlink'
value = None
defaultmulti = None
is_multi = False
else:
web_type = await childapi_option.type()
value = await childapi.option.default()
web_type = childapi_option.type()
value = childapi.option.default()
if value == []:
value = None
is_multi = await childapi_option.ismulti()
is_multi = childapi_option.ismulti()
if is_multi:
defaultmulti = await childapi_option.defaultmulti()
defaultmulti = childapi_option.defaultmulti()
if defaultmulti == []:
defaultmulti = None
else:
defaultmulti = None
if schema is not None:
await self.gen_schema(schema,
self.gen_schema(schema,
childapi,
childapi_option,
path,
@ -471,7 +471,7 @@ class TiramisuDict:
web_type,
form)
if form is not None:
await self.gen_form(form,
self.gen_form(form,
web_type,
path,
child,
@ -479,8 +479,8 @@ class TiramisuDict:
childtype)
if schema is not None:
if web_type != 'symlink':
schema[path]['title'] = await childapi_option.description()
await self.add_help(schema[path],
schema[path]['title'] = childapi_option.description()
self.add_help(schema[path],
childapi)
except Exception as err:
import traceback
@ -489,9 +489,9 @@ class TiramisuDict:
raise err
error = err
if init and form is not None:
await self.callbacks.process(form)
await self.requires.process(form)
await self.consistencies.process(form)
self.callbacks.process(form)
self.requires.process(form)
self.consistencies.process(form)
del self.requires
del self.consistencies
del self.callbacks
@ -501,7 +501,7 @@ class TiramisuDict:
raise ConfigError(_('unable to transform tiramisu object to dict: {}').format(msg))
async def gen_schema(self,
def gen_schema(self,
schema,
childapi,
childapi_option,
@ -513,8 +513,8 @@ class TiramisuDict:
web_type,
form):
schema[path] = {'type': web_type}
if await childapi_option.issymlinkoption():
sym_option = await childapi_option.get()
if childapi_option.issymlinkoption():
sym_option = childapi_option.get()
schema[path]['opt_path'] = sym_option.impl_getopt().impl_getpath()
else:
if defaultmulti is not None:
@ -523,7 +523,7 @@ class TiramisuDict:
if is_multi:
schema[path]['isMulti'] = is_multi
if await childapi_option.issubmulti():
if childapi_option.issubmulti():
schema[path]['isSubMulti'] = True
if 'auto_freeze' in props_no_requires:
@ -536,7 +536,7 @@ class TiramisuDict:
# if isinstance(values_param, ParamOption):
# self.set_remotable(path, form, childapi)
# return
schema[path]['enum'] = await self.get_enum(childapi,
schema[path]['enum'] = self.get_enum(childapi,
is_multi,
path,
props_no_requires)
@ -544,19 +544,19 @@ class TiramisuDict:
schema[path]['value'] = value
async def get_enum(self,
def get_enum(self,
childapi,
is_multi,
path,
props_no_requires):
values = await childapi.value.list()
empty_is_required = not await childapi.option.isfollower() and is_multi
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 \
(not empty_is_required and not 'mandatory' in props_no_requires)):
values = [''] + list(values)
return values
async def gen_form(self,
def gen_form(self,
form,
web_type,
path,
@ -566,7 +566,7 @@ class TiramisuDict:
obj_form = {}
if path in form:
obj_form.update(form[path])
if not await childapi_option.issymlinkoption():
if not childapi_option.issymlinkoption():
#if childapi_option.validator() != (None, None):
# obj_form['remote'] = True
# params = childapi_option.validator()[1]
@ -578,14 +578,14 @@ class TiramisuDict:
obj_form['clearable'] = True
if self.clearable != 'none':
obj_form['clearable'] = True
if self.remotable == 'all' or await childapi_option.has_dependency():
if self.remotable == 'all' or childapi_option.has_dependency():
obj_form['remote'] = True
if childtype == 'IPOption' and (child.impl_get_extra('_private_only') or not child.impl_get_extra('_allow_reserved') or child.impl_get_extra('_cidr')):
obj_form['remote'] = True
if childtype == 'DateOption':
obj_form['remote'] = True
if not obj_form.get('remote', False):
pattern = await childapi_option.pattern()
pattern = childapi_option.pattern()
if pattern is not None:
obj_form['pattern'] = pattern
if childtype == 'PortOption':
@ -600,37 +600,37 @@ class TiramisuDict:
if obj_form:
form[path] = obj_form
async def calc_raises_properties(self,
def calc_raises_properties(self,
obj,
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 = await self.config.property.get(default=True) # settings.get_context_properties(config._impl_properties_cache)
settings = config.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 = await childapi.property.get(only_raises=True,
properties = childapi.property.get(only_raises=True,
uncalculated=True)
properties -= await childapi.permissive.get()
properties -= childapi.permissive.get()
# 'hidden=True' means cannot access with or without permissive option
# 'display=False' means cannot access only without permissive option
if properties:
obj['display'] = False
properties -= await self.config.permissive.get()
properties -= self.config.permissive.get()
if properties:
obj['hidden'] = True
childapi._option_bag.config_bag.properties = old_properties
async def _gen_model_properties(self,
def _gen_model_properties(self,
childapi,
path,
index):
isfollower = await childapi.option.isfollower()
props = set(await childapi.property.get())
isfollower = childapi.option.isfollower()
props = set(childapi.property.get())
obj = self.gen_properties(props,
isfollower,
await childapi.option.ismulti(),
childapi.option.ismulti(),
index)
await self.calc_raises_properties(obj, childapi)
self.calc_raises_properties(obj, childapi)
return obj
def gen_properties(self,
@ -666,35 +666,35 @@ class TiramisuDict:
obj['properties'] = lprops
return obj
async def gen_model(self,
def gen_model(self,
model,
childapi,
path,
leader_len,
updates_status):
if await childapi.option.isoptiondescription():
props = set(await childapi.property.get())
if childapi.option.isoptiondescription():
props = set(childapi.property.get())
obj = {}
await self.calc_raises_properties(obj, childapi)
self.calc_raises_properties(obj, childapi)
if props:
lprops = list(props)
lprops.sort()
obj['properties'] = lprops
try:
await self.config.option(path).option.get()
self.config.option(path).option.get()
except PropertiesOptionError:
pass
else:
obj = await self._gen_model_properties(childapi,
obj = self._gen_model_properties(childapi,
path,
None)
if await childapi.option.isfollower():
if childapi.option.isfollower():
for index in range(leader_len):
follower_childapi = self.config.unrestraint.option(path, index)
sobj = await self._gen_model_properties(follower_childapi,
sobj = self._gen_model_properties(follower_childapi,
path,
index)
await self._get_model_value(follower_childapi,
self._get_model_value(follower_childapi,
path,
sobj,
index,
@ -702,25 +702,25 @@ class TiramisuDict:
if sobj:
model.setdefault(path, {})[str(index)] = sobj
else:
await self._get_model_value(childapi,
self._get_model_value(childapi,
path,
obj,
None,
updates_status)
if obj:
if not await childapi.option.isoptiondescription() and await childapi.option.isfollower():
if not childapi.option.isoptiondescription() and childapi.option.isfollower():
model.setdefault(path, {})['null'] = obj
else:
model[path] = obj
async def _get_model_value(self,
def _get_model_value(self,
childapi,
path,
obj,
index,
updates_status):
if path in updates_status and index in updates_status[path]:
value = await childapi.value.get()
value = childapi.value.get()
self._get_value_with_exception(obj,
childapi,
updates_status[path][index])
@ -728,7 +728,7 @@ class TiramisuDict:
else:
try:
with warnings.catch_warnings(record=True) as warns:
value = await self.config.option(path, index=index).value.get()
value = self.config.option(path, index=index).value.get()
self._get_value_with_exception(obj,
childapi,
warns)
@ -736,20 +736,20 @@ class TiramisuDict:
self._get_value_with_exception(obj,
childapi,
[err])
value = await self.config.unrestraint.option(path, index=index).value.get()
value = self.config.unrestraint.option(path, index=index).value.get()
except PropertiesOptionError as err:
config_bag = self.config._config_bag
settings = config_bag.context.cfgimpl_get_settings()
settings = config_bag.context.get_settings()
if settings._calc_raises_properties(config_bag.properties,
config_bag.permissives,
set(err.proptype)):
obj['hidden'] = True
obj['display'] = False
value = await childapi.value.get()
value = childapi.value.get()
if value is not None and value != []:
obj['value'] = value
if not await childapi.owner.isdefault():
obj['owner'] = await childapi.owner.get()
if not childapi.owner.isdefault():
obj['owner'] = childapi.owner.get()
def _get_value_with_exception(self,
obj,
@ -777,12 +777,12 @@ class TiramisuDict:
obj['warnings'].append(msg)
obj['hasWarnings'] = True
async def gen_global(self):
def gen_global(self):
ret = {}
ret['owner'] = await self.config.owner.get()
ret['properties'] = list(await self.config.property.get())
ret['owner'] = self.config.owner.get()
ret['properties'] = list(self.config.property.get())
ret['properties'].sort()
ret['permissives'] = list(await self.config.permissive.get())
ret['permissives'] = list(self.config.permissive.get())
ret['permissives'].sort()
return ret
@ -808,33 +808,33 @@ class TiramisuDict:
ret.extend(buttons)
return ret
async def del_value(self, childapi, path, index):
if index is not None and await childapi.option.isleader():
await childapi.value.pop(index)
elif index is None or await childapi.option.isfollower():
await childapi.value.reset()
def del_value(self, childapi, path, index):
if index is not None and childapi.option.isleader():
childapi.value.pop(index)
elif index is None or childapi.option.isfollower():
childapi.value.reset()
else:
multi = await childapi.value.get()
multi = childapi.value.get()
multi.pop(index)
await childapi.value.set(multi)
childapi.value.set(multi)
async def add_value(self, childapi, path, value):
multi = await childapi.value.get()
def add_value(self, childapi, path, value):
multi = childapi.value.get()
multi.append(value)
await childapi.value.set(multi)
childapi.value.set(multi)
async def mod_value(self, childapi, path, index, value):
if index is None or await childapi.option.isfollower():
await childapi.value.set(value)
def mod_value(self, childapi, path, index, value):
if index is None or childapi.option.isfollower():
childapi.value.set(value)
else:
multi = await childapi.value.get()
multi = childapi.value.get()
if len(multi) < index + 1:
multi.append(value)
else:
multi[index] = value
await childapi.value.set(multi)
childapi.value.set(multi)
async def apply_updates(self,
def apply_updates(self,
oripath,
updates,
model_ori):
@ -846,22 +846,22 @@ class TiramisuDict:
raise ValueError(_('not in current area'))
childapi = self.config.option(path)
childapi_option = childapi.option
if await childapi_option.isfollower():
if childapi_option.isfollower():
childapi = self.config.option(path, index)
with warnings.catch_warnings(record=True) as warns:
try:
if update['action'] == 'modify':
await self.mod_value(childapi,
self.mod_value(childapi,
path,
index,
update.get('value', undefined))
elif update['action'] == 'delete':
await self.del_value(childapi,
self.del_value(childapi,
path,
index)
elif update['action'] == 'add':
if await childapi_option.ismulti():
await self.add_value(childapi, path, update['value'])
if childapi_option.ismulti():
self.add_value(childapi, path, update['value'])
else:
raise ValueError(_('only multi option can have action "add", but "{}" is not a multi').format(path))
else:
@ -872,17 +872,17 @@ class TiramisuDict:
updates_status.setdefault(path, {}).setdefault(index, []).extend(warns)
return updates_status
async def set_updates(self,
def set_updates(self,
body):
root_path = self.root
updates = body.get('updates', [])
updates_status = await self.apply_updates(root_path,
updates_status = self.apply_updates(root_path,
updates,
body.get('model'))
if 'model' in body:
order = []
old_model = body['model']
new_model = await self.todict(order=order,
new_model = self.todict(order=order,
build_schema=False,
build_form=False,
updates_status=updates_status)
@ -892,7 +892,7 @@ class TiramisuDict:
values = updates_status
return values
async def todict(self,
def todict(self,
custom_form=[],
build_schema=True,
build_model=True,
@ -913,7 +913,7 @@ class TiramisuDict:
buttons = []
else:
form = None
await self.walk(rootpath,
self.walk(rootpath,
None,
schema,
model,
@ -936,7 +936,7 @@ class TiramisuDict:
ret['schema'] = schema
if build_model:
ret['model'] = model
ret['global'] = await self.gen_global()
ret['global'] = self.gen_global()
if build_form:
ret['form'] = form
ret['version'] = '1.0'

512
tiramisu/value.py
View file

@ -21,46 +21,37 @@ from .error import ConfigError, PropertiesOptionError
from .setting import owners, undefined, forbidden_owners, OptionBag, ConfigBag
from .autolib import Calculation, carry_out_calculation, Params
from .i18n import _
from .asyncinit import asyncinit
@asyncinit
class Values:
"""The `Config`'s root is indeed in charge of the `Option()`'s values,
but the values are physicaly located here, in `Values`, wich is also
responsible of a caching utility.
"""
__slots__ = ('_p_',
'__weakref__')
__slots__ = ('_values',
'_informations',
'__weakref__',
)
async def __init__(self,
storage,
connection):
def __init__(self,
default_values=None,
):
"""
Initializes the values's dict.
:param storage: where values or owners are stored
"""
# store the storage
self._p_ = storage
self._informations = {}
# set default owner
owner = await self._p_.getowner(connection,
None,
None,
None)
if owner is None:
await self._p_.setvalue(connection,
None,
None,
owners.user,
None,
new=True)
if not default_values:
self._values = {None: {None: [None, owners.user]}}
else:
self._values = default_values
#______________________________________________________________________
# get value
async def get_cached_value(self,
def get_cached_value(self,
option_bag: OptionBag,
) -> Any:
"""get value directly in cache if set
@ -80,15 +71,15 @@ class Values:
)
# no cached value so get value
if not is_cached:
value = await self.getvalue(option_bag)
value = self.getvalue(option_bag)
# validates and warns value
if not validated:
validate = await option_bag.option.impl_validate(value,
validate = option_bag.option.impl_validate(value,
option_bag,
check_error=True,
)
if 'warnings' in setting_properties:
await option_bag.option.impl_validate(value,
option_bag.option.impl_validate(value,
option_bag,
check_error=False,
)
@ -107,37 +98,35 @@ class Values:
# and return it
return value
async def force_to_metaconfig(self, option_bag):
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.cfgimpl_get_settings()
settings = option_bag.config_bag.context.get_settings()
if 'force_metaconfig_on_freeze' in option_bag.properties:
settings = option_bag.config_bag.context.cfgimpl_get_settings()
settings = option_bag.config_bag.context.get_settings()
if 'force_metaconfig_on_freeze' in option_bag.option.impl_getproperties() and \
not await settings._p_.getproperties(option_bag.config_bag.connection,
option_bag.path,
None,
frozenset()):
not settings._properties.get(option_bag.path, {}).get(None, frozenset()):
# if force_metaconfig_on_freeze is only in option (not in config)
return option_bag.config_bag.context.impl_type == 'config'
else:
return True
return False
async def _do_value_list(self,
def _do_value_list(self,
value: Any,
option_bag: OptionBag):
option_bag: OptionBag,
):
ret = []
for val in value:
if isinstance(val, (list, tuple)):
ret.append(await self._do_value_list(val, option_bag))
ret.append(self._do_value_list(val, option_bag))
elif isinstance(val, Calculation):
ret.append(await val.execute(option_bag))
ret.append(val.execute(option_bag))
else:
ret.append(val)
return ret
async def getvalue(self,
def getvalue(self,
option_bag,
):
"""actually retrieves the value
@ -156,37 +145,32 @@ class Values:
_index = None
else:
_index = index
owner, value = await self._p_.getowner(option_bag.config_bag.connection,
option_bag.path,
owners.default,
index=_index,
with_value=True,
)
value, owner = self._values.get(option_bag.path, {}).get(_index, [undefined, owners.default])
if owner == owners.default or \
('frozen' in option_bag.properties and \
('force_default_on_freeze' in option_bag.properties or await self.force_to_metaconfig(option_bag))):
value = await self.getdefaultvalue(option_bag)
('force_default_on_freeze' in option_bag.properties or self.force_to_metaconfig(option_bag))):
value = self.getdefaultvalue(option_bag)
else:
value = await self.calc_value(option_bag, value)
value = self.calc_value(option_bag, value)
return value
async def calc_value(self,
def calc_value(self,
option_bag,
value,
reset_cache=True):
if isinstance(value, Calculation):
try:
value = await value.execute(option_bag)
value = value.execute(option_bag)
except ConfigError as err:
msg = _(f'error when calculating "{option_bag.option.impl_get_display_name()}": {err} : {option_bag.path}')
raise ConfigError(msg) from err
elif isinstance(value, (list, tuple)):
value = await self._do_value_list(value, option_bag)
value = self._do_value_list(value, option_bag)
if reset_cache:
await self.calculate_reset_cache(option_bag, value)
self.calculate_reset_cache(option_bag, value)
return value
async def getdefaultvalue(self,
def getdefaultvalue(self,
option_bag,
):
"""get default value:
@ -194,19 +178,13 @@ class Values:
- get calculated value or
- get default value
"""
moption_bag = await self._get_modified_parent(option_bag)
moption_bag = self._get_modified_parent(option_bag)
if moption_bag is not None:
# retrieved value from parent config
return await moption_bag.config_bag.context.cfgimpl_get_values().get_cached_value(moption_bag)
if option_bag.option.impl_has_callback():
# default value is a calculated value
value = await self.calculate_value(option_bag)
if value is not undefined:
return value
return moption_bag.config_bag.context.get_values().get_cached_value(moption_bag)
# now try to get default value:
value = await self.calc_value(option_bag,
value = self.calc_value(option_bag,
option_bag.option.impl_getdefault(),
)
if option_bag.index is not None and isinstance(value, (list, tuple)):
@ -219,7 +197,7 @@ class Values:
else:
# no value for this index, retrieve default multi value
# default_multi is already a list for submulti
value = await self.calc_value(option_bag,
value = self.calc_value(option_bag,
option_bag.option.impl_getdefault_multi())
elif option_bag.option.impl_is_multi():
# if index, must return good value for this index
@ -228,11 +206,11 @@ class Values:
else:
# no value for this index, retrieve default multi value
# default_multi is already a list for submulti
value = await self.calc_value(option_bag,
value = self.calc_value(option_bag,
option_bag.option.impl_getdefault_multi())
return value
async def calculate_reset_cache(self,
def calculate_reset_cache(self,
option_bag,
value):
if not 'expire' in option_bag.properties:
@ -249,60 +227,10 @@ class Values:
# so do not invalidate cache
return
# calculated value is a new value, so reset cache
await option_bag.config_bag.context.cfgimpl_reset_cache(option_bag)
option_bag.config_bag.context.reset_cache(option_bag)
# and manage force_store_value
await self._set_force_value_suffix(option_bag)
self._set_force_value_suffix(option_bag)
async def calculate_value(self,
option_bag: OptionBag,
) -> Any:
# if value has callback, calculate value
callback, callback_params = option_bag.option.impl_get_callback()
value = await self.carry_out_calculation(option_bag,
callback,
callback_params)
if isinstance(value, list) and option_bag.index is not None:
# if value is a list and index is set
if option_bag.option.impl_is_submulti() and (value == [] or not isinstance(value[0], list)):
# return value only if it's a submulti and not a list of list
await self.calculate_reset_cache(option_bag, value)
return value
if len(value) > option_bag.index:
# return the value for specified index if found
await self.calculate_reset_cache(option_bag, value[option_bag.index])
return value[option_bag.index]
# there is no calculate value for this index,
# so return an other default value
else:
if option_bag.option.impl_is_submulti():
if isinstance(value, list):
# value is a list, but no index specified
if (value != [] and not isinstance(value[0], list)):
# if submulti, return a list of value
value = [value]
elif option_bag.index is not None:
# if submulti, return a list of value
value = [value]
else:
# return a list of list for a submulti
value = [[value]]
elif option_bag.option.impl_is_multi() and not isinstance(value, list) and option_bag.index is None:
# return a list for a multi
value = [value]
await self.calculate_reset_cache(option_bag, value)
return value
return undefined
async def carry_out_calculation(self,
option_bag: OptionBag,
callback: Callable,
callback_params: Optional[Params]) -> Any:
return await carry_out_calculation(option_bag.option,
callback=callback,
callback_params=callback_params,
index=option_bag.index,
config_bag=option_bag.config_bag)
def isempty(self,
opt,
value,
@ -319,21 +247,23 @@ class Values:
#______________________________________________________________________
# set value
async def setvalue(self,
def setvalue(self,
value,
option_bag):
option_bag,
):
context = option_bag.config_bag.context
owner = await self.get_context_owner(option_bag.config_bag.connection)
owner = self.get_context_owner()
if 'validator' in option_bag.config_bag.properties:
await self.setvalue_validation(value,
self.setvalue_validation(value,
option_bag)
if isinstance(value, list):
# copy
value = value.copy()
await self._setvalue(option_bag,
self._setvalue(option_bag,
value,
owner)
owner,
)
setting_properties = option_bag.config_bag.properties
validator = 'validator' in setting_properties and 'demoting_error_warning' not in setting_properties
if validator:
@ -345,46 +275,59 @@ class Values:
setting_properties,
validator)
if 'force_store_value' in setting_properties and option_bag.option.impl_is_leader():
await option_bag.option.impl_get_leadership().follower_force_store_value(self,
option_bag.option.impl_get_leadership().follower_force_store_value(self,
value,
option_bag,
owners.forced,
)
async def setvalue_validation(self,
def setvalue_validation(self,
value,
option_bag):
settings = option_bag.config_bag.context.cfgimpl_get_settings()
settings = option_bag.config_bag.context.get_settings()
# First validate properties with this value
opt = option_bag.option
settings.validate_frozen(option_bag)
val = await self.calc_value(option_bag, value, False)
val = self.calc_value(option_bag, value, False)
settings.validate_mandatory(val,
option_bag)
# Value must be valid for option
await opt.impl_validate(val,
opt.impl_validate(val,
option_bag,
check_error=True)
if 'warnings' in option_bag.config_bag.properties:
# No error found so emit warnings
await opt.impl_validate(value,
opt.impl_validate(value,
option_bag,
check_error=False)
async def _setvalue(self,
def _setvalue(self,
option_bag: OptionBag,
value: Any,
owner: str,
) -> None:
await option_bag.config_bag.context.cfgimpl_reset_cache(option_bag)
await self._p_.setvalue(option_bag.config_bag.connection,
option_bag.path,
option_bag.config_bag.context.reset_cache(option_bag)
self.set_storage_value(option_bag.path,
option_bag.index,
value,
owner,
option_bag.index)
await self._set_force_value_suffix(option_bag)
)
self._set_force_value_suffix(option_bag)
async def _set_force_value_suffix(self,
def reduce_index(self,
path,
index):
self._values[path][index - 1] = self._values[path].pop(index)
def set_storage_value(self,
path,
index,
value,
owner,
):
self._values.setdefault(path, {})[index] = [value, owner]
def _set_force_value_suffix(self,
option_bag: OptionBag,
) -> None:
if 'force_store_value' not in option_bag.config_bag.properties:
@ -392,7 +335,7 @@ class Values:
for woption in option_bag.option._get_suffixes_dependencies():
option = woption()
force_store_options = []
async for coption in option.get_children_recursively(None,
for coption in option.get_children_recursively(None,
None,
option_bag.config_bag,
):
@ -401,8 +344,8 @@ class Values:
if not force_store_options:
continue
rootpath = option.impl_getpath()
settings = option_bag.config_bag.context.cfgimpl_get_settings()
for suffix in await option.get_suffixes(option_bag.config_bag):
settings = option_bag.config_bag.context.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]
path_suffix = option.convert_suffix_to_path(suffix)
@ -413,32 +356,24 @@ class Values:
)
if coption.impl_is_follower():
leader = coption.impl_get_leadership().get_leader()
loption_bag = OptionBag()
loption_bag.set_option(leader,
loption_bag = OptionBag(leader,
None,
option_bag.config_bag,
properties=frozenset(),
)
loption_bag.properties = frozenset()
indexes = range(len(await self.getvalue(loption_bag)))
indexes = range(len(self.getvalue(loption_bag)))
else:
indexes = [None]
for index in indexes:
coption_bag = OptionBag()
coption_bag.set_option(doption,
coption_bag = OptionBag(doption,
index,
option_bag.config_bag,
)
coption_bag.properties = await settings.getproperties(coption_bag)
await self._p_.setvalue(coption_bag.config_bag.connection,
coption_bag.path,
await self.getvalue(coption_bag),
owners.forced,
index,
False,
)
self._values.setdefault(coption_bag.path, {})[index] = [self.getvalue(coption_bag), owners.forced]
async def _get_modified_parent(self,
option_bag: OptionBag) -> Optional[OptionBag]:
def _get_modified_parent(self,
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
@ -457,12 +392,12 @@ 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 = await doption_bag.config_bag.context.cfgimpl_get_settings().getproperties(doption_bag)
if not await self.force_to_metaconfig(doption_bag):
doption_bag.properties = doption_bag.config_bag.context.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 = await parent.cfgimpl_get_values().getowner(doption_bag,
parent_owner = parent.get_values().getowner(doption_bag,
only_default=True)
if parent_owner != owners.default:
return doption_bag
@ -473,14 +408,28 @@ class Values:
#______________________________________________________________________
# owner
async def is_default_owner(self,
def is_default_owner(self,
option_bag,
validate_meta=True):
return await self.getowner(option_bag,
return self.getowner(option_bag,
validate_meta=validate_meta,
only_default=True) == owners.default
async def getowner(self,
def hasvalue(self,
path,
index=None,
):
"""if path has a value
return: boolean
"""
has_path = path in self._values
if index is None:
return has_path
elif has_path:
return index in self._values[path]
return False
def getowner(self,
option_bag,
validate_meta=True,
only_default=False):
@ -499,36 +448,33 @@ class Values:
opt = opt.impl_getopt()
option_bag.option = opt
option_bag.path = opt.impl_getpath()
settings = context.cfgimpl_get_settings()
await settings.validate_properties(option_bag)
settings = context.get_settings()
settings.validate_properties(option_bag)
if 'frozen' in option_bag.properties and \
'force_default_on_freeze' in option_bag.properties:
return owners.default
if only_default:
if await self._p_.hasvalue(option_bag.config_bag.connection,
option_bag.path,
if self.hasvalue(option_bag.path,
option_bag.index):
owner = 'not_default'
else:
owner = owners.default
else:
owner = await self._p_.getowner(option_bag.config_bag.connection,
option_bag.path,
owners.default,
index=option_bag.index)
owner = self._values.get(option_bag.path, {}).get(option_bag.index, [undefined, owners.default])[1]
if validate_meta is not False and (owner is owners.default or \
'frozen' in option_bag.properties and 'force_metaconfig_on_freeze' in option_bag.properties):
moption_bag = await self._get_modified_parent(option_bag)
moption_bag = self._get_modified_parent(option_bag)
if moption_bag is not None:
owner = await moption_bag.config_bag.context.cfgimpl_get_values().getowner(moption_bag,
owner = moption_bag.config_bag.context.get_values().getowner(moption_bag,
only_default=only_default)
elif 'force_metaconfig_on_freeze' in option_bag.properties:
return owners.default
return owner
async def setowner(self,
def setowner(self,
owner,
option_bag):
option_bag,
):
"""
sets a owner to an option
@ -542,99 +488,108 @@ class Values:
if owner in forbidden_owners:
raise ValueError(_('set owner "{0}" is forbidden').format(str(owner)))
if not await self._p_.hasvalue(option_bag.config_bag.connection,
option_bag.path):
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.cfgimpl_get_settings().validate_frozen(option_bag)
await self._p_.setowner(option_bag.config_bag.connection,
option_bag.path,
owner,
index=option_bag.index)
option_bag.config_bag.context.get_settings().validate_frozen(option_bag)
self._values[option_bag.path][option_bag.index][1] = owner
#______________________________________________________________________
# reset
async def reset(self,
def reset(self,
option_bag):
context = option_bag.config_bag.context
hasvalue = await self._p_.hasvalue(option_bag.config_bag.connection,
option_bag.path)
hasvalue = self.hasvalue(option_bag.path)
setting_properties = option_bag.config_bag.properties
if hasvalue and 'validator' in option_bag.config_bag.properties:
fake_context = await context._gen_fake_values(option_bag.config_bag.connection)
fake_context = context._gen_fake_values()
config_bag = option_bag.config_bag.copy()
config_bag.remove_validation()
config_bag.context = fake_context
soption_bag = option_bag.copy()
soption_bag.config_bag = config_bag
fake_value = fake_context.cfgimpl_get_values()
await fake_value.reset(soption_bag)
fake_value = fake_context.get_values()
fake_value.reset(soption_bag)
soption_bag.config_bag.properties = option_bag.config_bag.properties
value = await fake_value.getdefaultvalue(soption_bag)
await fake_value.setvalue_validation(value,
value = fake_value.getdefaultvalue(soption_bag)
fake_value.setvalue_validation(value,
soption_bag)
opt = option_bag.option
if opt.impl_is_leader():
await opt.impl_get_leadership().reset(self,
opt.impl_get_leadership().reset(self,
option_bag)
if hasvalue:
if 'force_store_value' in option_bag.config_bag.properties and 'force_store_value' in option_bag.properties:
value = await self.getdefaultvalue(option_bag)
value = self.getdefaultvalue(option_bag)
await self._setvalue(option_bag,
self._setvalue(option_bag,
value,
owners.forced)
owners.forced,
)
else:
# for leader only
value = None
await self._p_.resetvalue(option_bag.config_bag.connection,
option_bag.path)
await context.cfgimpl_reset_cache(option_bag)
if option_bag.path in self._values:
del self._values[option_bag.path]
context.reset_cache(option_bag)
if 'force_store_value' in setting_properties and option_bag.option.impl_is_leader():
if value is None:
value = await self.getdefaultvalue(option_bag)
await option_bag.option.impl_get_leadership().follower_force_store_value(self,
value = self.getdefaultvalue(option_bag)
option_bag.option.impl_get_leadership().follower_force_store_value(self,
value,
option_bag,
owners.forced)
async def reset_follower(self,
def get_max_length(self, path):
values = self._values.get(path, {})
if values:
return max(values) + 1
return 0
def reset_follower(self,
option_bag):
if await self._p_.hasvalue(option_bag.config_bag.connection,
option_bag.path,
if self.hasvalue(option_bag.path,
index=option_bag.index):
context = option_bag.config_bag.context
setting_properties = option_bag.config_bag.properties
if 'validator' in setting_properties:
fake_context = await context._gen_fake_values(option_bag.config_bag.connection)
fake_value = fake_context.cfgimpl_get_values()
fake_context = context._gen_fake_values()
fake_value = fake_context.get_values()
config_bag = option_bag.config_bag.copy()
config_bag.remove_validation()
config_bag.context = fake_context
soption_bag = option_bag.copy()
soption_bag.config_bag = config_bag
await fake_value.reset_follower(soption_bag)
value = await fake_value.getdefaultvalue(soption_bag)
await fake_value.setvalue_validation(value,
fake_value.reset_follower(soption_bag)
value = fake_value.getdefaultvalue(soption_bag)
fake_value.setvalue_validation(value,
soption_bag)
if 'force_store_value' in setting_properties and 'force_store_value' in option_bag.properties:
value = await self.getdefaultvalue(option_bag)
value = self.getdefaultvalue(option_bag)
await self._setvalue(option_bag,
self._setvalue(option_bag,
value,
owners.forced)
owners.forced,
)
else:
await self._p_.resetvalue_index(option_bag.config_bag.connection,
option_bag.path,
option_bag.index)
await context.cfgimpl_reset_cache(option_bag)
self.resetvalue_index(option_bag.path,
option_bag.index,
)
context.reset_cache(option_bag)
async def reset_leadership(self,
def resetvalue_index(self,
path,
index,
):
if path in self._values and index in self._values[path]:
del self._values[path][index]
def reset_leadership(self,
index,
option_bag,
subconfig):
current_value = await self.get_cached_value(option_bag)
current_value = self.get_cached_value(option_bag)
length = len(current_value)
if index >= length:
raise IndexError(_('index {} is greater than the length {} '
@ -642,16 +597,17 @@ class Values:
length,
option_bag.option.impl_get_display_name()))
current_value.pop(index)
await subconfig.cfgimpl_get_description().pop(self,
subconfig.get_description().pop(self,
index,
option_bag)
await self.setvalue(current_value,
option_bag)
self.setvalue(current_value,
option_bag,
)
#______________________________________________________________________
# information
async def set_information(self,
def set_information(self,
config_bag,
option_bag,
key,
@ -666,15 +622,12 @@ class Values:
path = None
else:
path = option_bag.path
await self._p_.set_information(config_bag.connection,
path,
key,
value)
self._informations.setdefault(path, {})[key] = value
if path is not None:
for option in option_bag.option.get_dependencies_information(itself=True):
await config_bag.context.cfgimpl_reset_cache(option_bag)
config_bag.context.reset_cache(option_bag)
async def get_information(self,
def get_information(self,
config_bag,
option_bag,
key,
@ -689,10 +642,7 @@ class Values:
else:
path = option_bag.path
try:
return await self._p_.get_information(config_bag.connection,
path,
key,
)
return self._informations[path][key]
except KeyError as err:
if option_bag:
return option_bag.option.impl_get_information(key, default)
@ -700,74 +650,71 @@ class Values:
return default
raise ValueError(_("information's item not found: {0}").format(key))
async def del_information(self,
connection,
def del_information(self,
key,
raises=True,
path=None):
await self._p_.del_information(connection,
path,
key,
raises)
path=None,
):
if path in self._informations and key in self._informations[path]:
del self._informations[path][key]
elif raises:
raise ValueError(_(f"information's item not found \"{key}\""))
async def list_information(self,
connection,
path=None):
return await self._p_.list_information(connection,
path)
def list_information(self,
path=None,
):
return list(self._informations.get(path, {}).keys())
#______________________________________________________________________
# mandatory warnings
async def _mandatory_warnings(self,
def _mandatory_warnings(self,
context,
config_bag,
description,
description_bag,
currpath,
subconfig,
od_config_bag):
settings = context.cfgimpl_get_settings()
for option in await description.get_children(config_bag):
):
settings = context.get_settings()
for option in description_bag.option.get_children(config_bag):
name = option.impl_getname()
if option.impl_is_symlinkoption():
continue
if option.impl_is_optiondescription():
try:
option_bag = OptionBag()
option_bag.set_option(option,
option_bag = OptionBag(option,
None,
od_config_bag)
option_bag.properties = await settings.getproperties(option_bag)
description_bag.config_bag,
)
subsubconfig = await subconfig.get_subconfig(option_bag)
subsubconfig = subconfig.get_subconfig(option_bag)
except PropertiesOptionError as err:
pass
else:
async for option in self._mandatory_warnings(context,
for option in self._mandatory_warnings(context,
config_bag,
option,
option_bag,
currpath + [name],
subsubconfig,
od_config_bag):
):
yield option
elif not option.impl_is_symlinkoption():
# don't verifying symlink
else:
try:
if not option.impl_is_follower():
option_bag = OptionBag()
option_bag.set_option(option,
option_bag = OptionBag(option,
None,
config_bag)
option_bag.properties = await settings.getproperties(option_bag)
config_bag,
)
if 'mandatory' in option_bag.properties or 'empty' in option_bag.properties:
await subconfig.getattr(name,
subconfig.getattr(name,
option_bag)
else:
for index in range(subconfig.cfgimpl_get_length()):
option_bag = OptionBag()
option_bag.set_option(option,
for index in range(subconfig.get_length_leadership(description_bag)):
option_bag = OptionBag(option,
index,
config_bag)
option_bag.properties = await settings.getproperties(option_bag)
config_bag,
)
if 'mandatory' in option_bag.properties or 'empty' in option_bag.properties:
await subconfig.getattr(name,
subconfig.getattr(name,
option_bag)
except PropertiesOptionError as err:
if err.proptype in (['mandatory'], ['empty']):
@ -775,8 +722,9 @@ class Values:
except ConfigError:
pass
async def mandatory_warnings(self,
config_bag):
def mandatory_warnings(self,
config_bag,
):
"""convenience function to trace Options that are mandatory and
where no value has been set
@ -790,40 +738,32 @@ class Values:
nconfig_bag = ConfigBag(context=config_bag.context,
properties=frozenset(setting_properties),
permissives=config_bag.permissives)
nconfig_bag.connection = config_bag.connection
nconfig_bag.set_permissive()
od_config_bag = ConfigBag(context=nconfig_bag.context,
properties=frozenset(od_setting_properties),
permissives=nconfig_bag.permissives)
od_config_bag.connection = config_bag.connection
od_config_bag.set_permissive()
descr = context.cfgimpl_get_description()
async for option in self._mandatory_warnings(context,
descr = context.get_description()
option_bag = OptionBag(descr,
None,
od_config_bag,
)
for option in self._mandatory_warnings(context,
nconfig_bag,
descr,
option_bag,
[],
context,
od_config_bag):
):
yield option
#____________________________________________________________
# default owner methods
async def set_context_owner(self,
connection,
owner):
def set_context_owner(self, owner):
":param owner: sets the default value for owner at the Config level"
if owner in forbidden_owners:
raise ValueError(_('set owner "{0}" is forbidden').format(str(owner)))
self._values[None][None][1] = owner
await self._p_.setowner(connection,
None,
owner,
index=None)
async def get_context_owner(self,
connection):
return await self._p_.getowner(connection,
None,
None,
None)
def get_context_owner(self):
return self._values[None][None][1]