stove/tiramisu
3
0
Fork 0
Code Issues 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 40cb47453b
77 changed files with 13021 additions and 17034 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_.option(path).value.get() == empty_value
assert cfg_.forcepermissive.option(path).value.get() == empty_value assert cfg_.forcepermissive.option(path).value.get() == empty_value
elif not kwargs.get('propertyerror', False): 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 assert cfg_.forcepermissive.option(path).value.get() == empty_value
else: else:
raises(PropertiesOptionError, "cfg_.option(path).value.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(path).value.get()") cfg_.option(path).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(path).value.get()
else: else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(path, 0).value.get() == empty_value 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, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(path, 1).value.get() == empty_value assert cfg_.forcepermissive.option(path, 1).value.get() == empty_value
elif not kwargs.get('propertyerror', False): 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, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(path, 1).value.get() == empty_value assert cfg_.forcepermissive.option(path, 1).value.get() == empty_value
else: else:
raises(PropertiesOptionError, "cfg_.option(path, 0).value.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(path, 0).value.get()") cfg_.option(path, 0).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(path, 0).value.get()
def _set_value(cfg, pathwrite, conf, **kwargs): 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: with warnings.catch_warnings(record=True) as w:
if isleader: if isleader:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): 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: if not set_permissive:
cfg_.option(pathwrite).value.set([first_value[0]]) cfg_.option(pathwrite).value.set([first_value[0]])
else: else:
cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]]) cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])
elif not kwargs.get('propertyerror', False): 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: if set_permissive:
cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]]) cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])
else: else:
raises(PropertiesOptionError, "cfg_.option(pathwrite).value.set([first_value[0]])") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])") 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: 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: elif isfollower:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not set_permissive: if not set_permissive:
@ -163,13 +174,17 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
else: else:
cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value) cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)
elif not kwargs.get('propertyerror', False): 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: if set_permissive:
cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value) cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)
else: else:
raises(PropertiesOptionError, "cfg_.option(pathwrite, 1).value.set(second_value)") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)") cfg_.option(pathwrite, 1).value.set(second_value)
raises(APIError, "cfg_.unrestraint.option(pathwrite).value.set([second_value, 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: else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
@ -178,12 +193,15 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
else: else:
cfg_.forcepermissive.option(pathwrite).value.set(first_value) cfg_.forcepermissive.option(pathwrite).value.set(first_value)
elif not kwargs.get('propertyerror', False): 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: if set_permissive:
cfg_.forcepermissive.option(pathwrite).value.set(first_value) cfg_.forcepermissive.option(pathwrite).value.set(first_value)
else: else:
raises(PropertiesOptionError, "cfg_.option(pathwrite).value.set(first_value)") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathwrite).value.set(first_value)") 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)") #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_permissive)
assert set(cfg_.option(pathread).property.get()) == set(props) assert set(cfg_.option(pathread).property.get()) == set(props)
else: else:
raises(PropertiesOptionError, "cfg_.option(pathread).property.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.option(pathread).property.get()") 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_permissive)
assert set(cfg_.forcepermissive.option(pathread).property.get()) == set(props) assert set(cfg_.forcepermissive.option(pathread).property.get()) == set(props)
assert set(cfg_.unrestraint.option(pathread).property.get()) == set(props_permissive) 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_permissive)
assert set(cfg_.option(pathread, 1).property.get()) == set(props) assert set(cfg_.option(pathread, 1).property.get()) == set(props)
else: else:
raises(PropertiesOptionError, "cfg_.option(pathread, 0).property.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.option(pathread, 0).property.get()") cfg_.option(pathread, 0).property.get()
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).property.get()
# #
raises(PropertiesOptionError, "cfg_.option(pathread, 1).property.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.option(pathread, 1).property.get()") 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_permissive)
assert set(cfg_.forcepermissive.option(pathread, 0).property.get()) == set(props) 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, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value
elif kwargs.get('permissive', False): 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, 0).value.get() == empty_value
if set_permissive: if set_permissive:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value
else: else:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == empty_value assert cfg_.forcepermissive.option(pathread, 1).value.get() == empty_value
else: else:
raises(PropertiesOptionError, "cfg_.option(pathread, 0).value.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).value.get()") cfg_.option(pathread, 0).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).value.get()
else: else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(pathread).value.get() == first_value assert cfg_.option(pathread).value.get() == first_value
assert cfg_.forcepermissive.option(pathread).value.get() == first_value assert cfg_.forcepermissive.option(pathread).value.get() == first_value
elif kwargs.get('permissive', False): elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()") with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
if set_permissive: if set_permissive:
assert cfg_.forcepermissive.option(pathread).value.get() == first_value assert cfg_.forcepermissive.option(pathread).value.get() == first_value
else: else:
assert cfg_.forcepermissive.option(pathread).value.get() == empty_value assert cfg_.forcepermissive.option(pathread).value.get() == empty_value
else: else:
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).value.get()") cfg_.option(pathread).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).value.get()
def _check_owner(cfg, pathread, conf, kwargs, owner, permissive_owner): 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_.option(pathread).owner.get() == owner
assert cfg_.forcepermissive.option(pathread).owner.get() == owner assert cfg_.forcepermissive.option(pathread).owner.get() == owner
elif not kwargs.get('propertyerror', False): 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 assert cfg_.forcepermissive.option(pathread).owner.get() == permissive_owner
else: else:
raises(PropertiesOptionError, "cfg_.option(pathread).owner.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).owner.get()") cfg_.option(pathread).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).owner.get()
else: else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(pathread, 0).owner.get() == 'default' 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_.option(pathread, 1).owner.get() == owner
assert cfg_.forcepermissive.option(pathread, 1).owner.get() == owner assert cfg_.forcepermissive.option(pathread, 1).owner.get() == owner
elif not kwargs.get('propertyerror', False): elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.option(pathread, 1).owner.get()") 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, 0).owner.get() == 'default'
assert cfg_.forcepermissive.option(pathread, 1).owner.get() == permissive_owner assert cfg_.forcepermissive.option(pathread, 1).owner.get() == permissive_owner
else: else:
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).owner.get()") cfg_.option(pathread, 0).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).owner.get()
@autocheck @autocheck
def autocheck_option_multi(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs): 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): if not kwargs.get('permissive_od', False):
cfg.option(pathread).option.ismulti() cfg.option(pathread).option.ismulti()
cfg.option(pathread).option.issubmulti() cfg.option(pathread).option.issubmulti()
cfg.option(pathread).option.isleader() cfg.option(pathread).option.isleader()
cfg.option(pathread).option.isfollower() cfg.option(pathread).option.isfollower()
else: else:
raises(PropertiesOptionError, "cfg.option(pathread).option.ismulti()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg.option(pathread).option.issubmulti()") cfg.option(pathread).option.ismulti()
raises(PropertiesOptionError, "cfg.option(pathread).option.isleader()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg.option(pathread).option.isfollower()") 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.ismulti()
cfg.forcepermissive.option(pathread).option.issubmulti() 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): def autocheck_default_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""check different value of owner when any value is set to this option """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() isfollower = cfg.unrestraint.option(pathread).option.isfollower()
# check if owner is a string "default" and 'isdefault' # check if owner is a string "default" and 'isdefault'
def do(conf): 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_.option(pathread).owner.isdefault()
assert cfg_.forcepermissive.option(pathread).owner.isdefault() assert cfg_.forcepermissive.option(pathread).owner.isdefault()
elif not kwargs.get('propertyerror', False): 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' 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() assert cfg_.forcepermissive.option(pathread).owner.isdefault()
else: else:
raises(PropertiesOptionError, "cfg_.option(pathread).owner.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).owner.get()") cfg_.option(pathread).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).owner.get()
# #
raises(PropertiesOptionError, "cfg_.option(pathread).owner.isdefault()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).owner.isdefault()") 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.get() == 'default'
assert cfg_.unrestraint.option(pathread).owner.isdefault() 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_.option(pathread, 0).owner.isdefault()
assert cfg_.forcepermissive.option(pathread, 0).owner.isdefault() assert cfg_.forcepermissive.option(pathread, 0).owner.isdefault()
elif not kwargs.get('propertyerror', False): 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' 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() assert cfg_.forcepermissive.option(pathread, 0).owner.isdefault()
else: else:
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).owner.get()") cfg_.option(pathread, 0).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).owner.get()
# #
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.isdefault()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).owner.isdefault()") 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.get() == 'default'
assert cfg_.unrestraint.option(pathread, 0).owner.isdefault() assert cfg_.unrestraint.option(pathread, 0).owner.isdefault()
do(confread) 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_.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
assert cfg_.forcepermissive.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): elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "assert cfg_.option(pathread, 0).value.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "assert cfg_.option(pathread, 1).value.get()") 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 assert cfg_.forcepermissive.option(pathread, 0).value.get() == empty_value
if submulti_: if submulti_:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1] assert cfg_.forcepermissive.option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1]
else: else:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1] assert cfg_.forcepermissive.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
else: else:
raises(PropertiesOptionError, "assert cfg_.option(pathread, 0).value.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "assert cfg_.option(pathread, 1).value.get()") assert cfg_.option(pathread, 0).value.get()
raises(PropertiesOptionError, "assert cfg_.forcepermissive.option(pathread, 0).value.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "assert cfg_.forcepermissive.option(pathread, 1).value.get()") 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: else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
with warnings.catch_warnings(record=True) as w: with warnings.catch_warnings(record=True) as w:
assert cfg_.option(pathread).value.get() == first_value assert cfg_.option(pathread).value.get() == first_value
assert cfg_.forcepermissive.option(pathread).value.get() == first_value assert cfg_.forcepermissive.option(pathread).value.get() == first_value
elif kwargs.get('permissive', False): 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 assert cfg_.forcepermissive.option(pathread).value.get() == first_value
else: else:
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).value.get()") cfg_.option(pathread).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).value.get()
with warnings.catch_warnings(record=True) as w: with warnings.catch_warnings(record=True) as w:
do(confread) do(confread)
if confread != confwrite: if confread != confwrite:
@ -539,6 +606,9 @@ def autocheck_get_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
@autocheck @autocheck
def autocheck_value_follower(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs): 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() isfollower = cfg.unrestraint.option(pathread).option.isfollower()
if not isfollower: if not isfollower:
return 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): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg_.option(pathwrite).value.reset() cfg_.option(pathwrite).value.reset()
#else: #else:
#FIXME raises(PropertiesOptionError, "cfg.config(confwrite).option(pathwrite).value.reset()") #FIXME with raises(PropertiesOptionError):cfg.config(confwrite).option(pathwrite).value.reset()")
else: else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg_.option(pathwrite, 0).value.reset() cfg_.option(pathwrite, 0).value.reset()
#else: #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 # get value after reset value without permissive
def do(conf): 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, 0).value.get() == empty_value
assert cfg_.option(pathread, 1).value.get() == second_value[1] assert cfg_.option(pathread, 1).value.get() == second_value[1]
elif kwargs.get('permissive', False): 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, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value[1] assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value[1]
else: else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(pathread).value.get() == empty_value assert cfg_.option(pathread).value.get() == empty_value
elif kwargs.get('permissive', False): 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 assert cfg_.forcepermissive.option(pathread).value.get() == first_value
with warnings.catch_warnings(record=True) as w: with warnings.catch_warnings(record=True) as w:
do(confread) do(confread)
@ -667,8 +739,6 @@ def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite,
v3 = cfg_.forcepermissive.option(pathread).value.get() v3 = cfg_.forcepermissive.option(pathread).value.get()
len_value = len(leader_value) len_value = len(leader_value)
leader_value.append(undefined) 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 assert len(cfg_.forcepermissive.option(pathread).value.get()) == len_value
with warnings.catch_warnings(record=True) as w: with warnings.catch_warnings(record=True) as w:
cfg2_.forcepermissive.option(pathread).value.set(leader_value) cfg2_.forcepermissive.option(pathread).value.set(leader_value)
@ -688,12 +758,7 @@ def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite,
value = 'value' value = 'value'
else: else:
value = ['value'] 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) 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) assert len(cfg_.forcepermissive.option(pathread).value.get()) == len(new_leader_value)
cfg2_.forcepermissive.option(pathread).value.set(leader_value) cfg2_.forcepermissive.option(pathread).value.set(leader_value)
assert cfg_.forcepermissive.option(pathread).value.get()[-1] == 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() cfg.forcepermissive.option(pathwrite, 1).value.reset()
#FIXME else: #FIXME else:
# if not isfollower: # 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: # 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) _autocheck_default_value(cfg, pathread, confread, **kwargs)
if confread != confwrite: if confread != confwrite:
_autocheck_default_value(cfg, pathwrite, confwrite, **kwargs) _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): def autocheck_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""get property from path """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 # check if is a multi or a follower
multi = cfg.unrestraint.option(pathread).option.ismulti() multi = cfg.unrestraint.option(pathread).option.ismulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower() isfollower = cfg.unrestraint.option(pathread).option.isfollower()
@ -849,6 +917,9 @@ def autocheck_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kw
@autocheck @autocheck
def autocheck_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs): 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) _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): def autocheck_reset_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""check properties after set with permissive """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 # check if is a multi or a follower
multi = cfg.unrestraint.option(pathread).option.ismulti() multi = cfg.unrestraint.option(pathread).option.ismulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower() isfollower = cfg.unrestraint.option(pathread).option.isfollower()
@ -879,6 +953,9 @@ def autocheck_reset_property(cfg, mcfg, pathread, pathwrite, confread, confwrite
@autocheck @autocheck
def autocheck_reset_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs): def autocheck_reset_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi or a follower # 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() multi = cfg.unrestraint.option(pathread).option.ismulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower() isfollower = cfg.unrestraint.option(pathread).option.isfollower()
default_props, properties = _getproperties(multi, isfollower, kwargs) 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): def autocheck_owner_with_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""value is now changed, check owner in this case """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) _set_value(cfg, pathwrite, confwrite, **kwargs)
_check_owner(cfg, pathread, confwrite, kwargs, kwargs['owner'], kwargs['owner']) _check_owner(cfg, pathread, confwrite, kwargs, kwargs['owner'], kwargs['owner'])
if confread != confwrite: if confread != confwrite:
@ -926,8 +1005,8 @@ def autocheck_default_owner_with_value(cfg, mcfg, pathread, pathwrite, confread,
if confwrite != confread: if confwrite != confread:
assert cfg2_.option(pathread).owner.isdefault() is False assert cfg2_.option(pathread).owner.isdefault() is False
#FIXME else: #FIXME else:
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathread).owner.isdefault()") # with raises(PropertiesOptionError):cfg.config(confwrite).option(pathread).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confread).option(pathread).owner.isdefault()") # with raises(PropertiesOptionError):cfg.config(confread).option(pathread).owner.isdefault()")
else: else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg2_.option(pathread, 0).owner.isdefault() is True 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, 0).owner.isdefault() is True
assert cfg_.option(pathread, 1).owner.isdefault() is False assert cfg_.option(pathread, 1).owner.isdefault() is False
#FIXME else: #FIXME else:
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathread, 0).owner.isdefault()") # with 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(confread).option(pathread, 0).owner.isdefault()")
@autocheck @autocheck
@ -973,14 +1052,18 @@ def autocheck_set_owner_no_value(cfg, mcfg, pathread, pathwrite, confread, confw
cfg_ = cfg.forcepermissive cfg_ = cfg.forcepermissive
if not kwargs.get('propertyerror', False): if not kwargs.get('propertyerror', False):
if not isfollower: if not isfollower:
raises(ConfigError, "cfg_.option(pathwrite).owner.set('new_user')") with raises(ConfigError):
cfg_.option(pathwrite).owner.set('new_user')
else: else:
raises(ConfigError, "cfg_.option(pathwrite, 1).owner.set('new_user')") with raises(ConfigError):
cfg_.option(pathwrite, 1).owner.set('new_user')
@autocheck @autocheck
def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs): def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# test set owner without permissive # 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() isfollower = cfg.unrestraint.option(pathread).option.isfollower()
_set_value(cfg, pathwrite, confwrite, **kwargs) _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 isfollower:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg_.option(pathwrite).owner.set('new_user') cfg_.option(pathwrite).owner.set('new_user')
raises(ValueError, "cfg_.option(pathwrite).owner.set('default')") with raises(ValueError):
raises(ValueError, "cfg_.option(pathwrite).owner.set('forced')") cfg_.option(pathwrite).owner.set('default')
with raises(ValueError):
cfg_.option(pathwrite).owner.set('forced')
#FIXME else: #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: else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg.option(pathwrite, 1).owner.set('new_user') cfg.option(pathwrite, 1).owner.set('new_user')
#FIXME else: #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']) _check_owner(cfg, pathread, confwrite, kwargs, owners.new_user, kwargs['owner'])
if confwrite != confread: if confwrite != confread:
@ -1010,6 +1095,8 @@ def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
@autocheck @autocheck
def autocheck_set_owner_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs): 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() isfollower = cfg.unrestraint.option(pathread).option.isfollower()
_set_value(cfg, pathwrite, confwrite, **kwargs) _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') cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user1')
#FIXME else: #FIXME else:
# if not isfollower: # if not isfollower:
# raises(PropertiesOptionError, # with raises(PropertiesOptionError,
# "cfg.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user1')") # "cfg.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user1')")
# else: # else:
# raises(PropertiesOptionError, # with raises(PropertiesOptionError,
# "cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user1')") # "cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user1')")
_check_owner(cfg, pathread, confwrite, kwargs, 'new_user1', '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 @autocheck
def autocheck_option(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs): 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] expected_name = pathread.split('.')[-1]
if not kwargs.get('permissive_od', False): if not kwargs.get('permissive_od', False):
current_name = cfg.option(pathread).option.name() 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.forcepermissive.option(pathread).option.doc()
assert doc == cfg.unrestraint.option(pathread).option.doc() assert doc == cfg.unrestraint.option(pathread).option.doc()
elif not kwargs.get('propertyerror', False): 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() current_name = cfg.forcepermissive.option(pathread).option.name()
assert current_name == cfg.unrestraint.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() doc = cfg.forcepermissive.option(pathread).option.doc()
assert doc == cfg.unrestraint.option(pathread).option.doc() assert doc == cfg.unrestraint.option(pathread).option.doc()
else: else:
raises(PropertiesOptionError, "cfg.option(pathread).option.name()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.name()") cfg.option(pathread).option.name()
with raises(PropertiesOptionError):
cfg.forcepermissive.option(pathread).option.name()
current_name = cfg.unrestraint.option(pathread).option.name() current_name = cfg.unrestraint.option(pathread).option.name()
raises(PropertiesOptionError, "cfg.option(pathread).option.doc()") with raises(PropertiesOptionError):
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.doc()") cfg.option(pathread).option.doc()
with raises(PropertiesOptionError):
cfg.forcepermissive.option(pathread).option.doc()
doc = cfg.unrestraint.option(pathread).option.doc() doc = cfg.unrestraint.option(pathread).option.doc()
assert current_name == expected_name assert current_name == expected_name
if expected_name.endswith('val1') or expected_name.endswith('val2'): 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_.option.find(name, first=True))
assert option == _getoption(cfg_.forcepermissive.option.find(name, first=True)) assert option == _getoption(cfg_.forcepermissive.option.find(name, first=True))
elif kwargs.get('permissive', False): 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)) assert option == _getoption(cfg_.forcepermissive.option.find(name, first=True))
else: else:
raises(AttributeError, "cfg_.option.find(name, first=True)") with raises(AttributeError):
raises(AttributeError, "cfg_.forcepermissive.option.find(name, first=True)") 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 == _getoption(cfg_.unrestraint.option.find(name, first=True))
assert [option] == _getoptions(cfg_.unrestraint.option.find(name)) assert [option] == _getoptions(cfg_.unrestraint.option.find(name))
do(confread) do(confread)
@ -1372,11 +1471,11 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
for func in autocheck_registers: for func in autocheck_registers:
cfg_name = 'conftest' + str(idx) cfg_name = 'conftest' + str(idx)
idx += 1 idx += 1
ncfg = cfg.config.copy(session_id=cfg_name) ncfg = cfg.config.copy(name=cfg_name)
if meta: if meta:
confwrite = None confwrite = None
confread = cfg_name confread = cfg_name
mcfg = MetaConfig([ncfg], session_id='metatest') mcfg = MetaConfig([ncfg], name='metatest')
weakrefs.append(weakref.ref(cfg)) weakrefs.append(weakref.ref(cfg))
else: else:
mcfg = ncfg mcfg = ncfg
@ -1545,11 +1644,11 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
call_kwargs['requires'] = option_requires call_kwargs['requires'] = option_requires
else: else:
kwargs['requires'] = option_requires kwargs['requires'] = option_requires
if multi and path is not 'extraoptrequire': if multi and path != 'extraoptrequire':
kwargs['multi'] = multi kwargs['multi'] = multi
if callback: if callback:
call_kwargs['multi'] = multi 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: if multi is False:
value = FIRST_VALUE value = FIRST_VALUE
elif multi is True: elif multi is True:
@ -1563,7 +1662,7 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
kwargs['default'] = value kwargs['default'] = value
elif callback: elif callback:
return None, None, None return None, None, None
if default_multi and path is not 'extraoptrequire': if default_multi and path != 'extraoptrequire':
if multi is not submulti: if multi is not submulti:
value = SECOND_VALUE value = SECOND_VALUE
else: else:
@ -1585,7 +1684,6 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
tiramisu_option = SymLinkOption tiramisu_option = SymLinkOption
else: else:
sobj = None sobj = None
print(args, kwargs)
obj = tiramisu_option(*args, **kwargs) obj = tiramisu_option(*args, **kwargs)
return obj, objcall, sobj 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) rootod = make_optiondescriptions('root', collect_options)
if rootod is None: if rootod is None:
return None, None, None return None, None, None
cfg = Config(rootod, session_id='conftest') cfg = Config(rootod, name='conftest')
weakrefs.append(weakref.ref(cfg)) weakrefs.append(weakref.ref(cfg))
del goptions del goptions
return cfg, weakrefs, dyn return cfg, weakrefs, dyn

49
tests/config.py
View file

@ -21,11 +21,11 @@ except:
import pytest import pytest
async def get_config(config, type, error=False): def get_config(config, type, error=False):
if type == 'tiramisu': if type == 'tiramisu':
return config return config
if error: if error:
await config.property.add('demoting_error_warning') config.property.add('demoting_error_warning')
return TestConfig(config) return TestConfig(config)
@ -35,51 +35,10 @@ def value_list(values):
return tuple(values) return tuple(values)
async def global_owner(config, config_type): def global_owner(config, config_type):
return await config.owner.get() return config.owner.get()
@pytest.fixture(params=PARAMS) @pytest.fixture(params=PARAMS)
def config_type(request): def config_type(request):
return request.param 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 return descr
async def get_values(api, allpath=False): def get_values(api, allpath=False):
if allpath: if allpath:
root = 'choice1_leadership_value.' root = 'choice1_leadership_value.'
else: else:
root = '' root = ''
await api.option(root + 'options.choice1.choice1').value.set(['choice 2']) 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.choice2', 0).value.set('choice 4')

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

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

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

@ -10,9 +10,9 @@ def get_description():
return descr return descr
async def get_values(api, allpath=False): def get_values(api, allpath=False):
if allpath: if allpath:
root = 'number1_mod_value.' root = 'number1_mod_value.'
else: else:
root = '' 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 return descr
async def get_values(api, allpath=False): def get_values(api, allpath=False):
if allpath: if allpath:
root = 'unicode1_leadership_hidden.' root = 'unicode1_leadership_hidden.'
else: else:
root = '' root = ''
await api.option(root + 'options.unicode.unicode').value.set([u'val1', u'val2']) 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.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 return descr
async def get_values(api, allpath=False): def get_values(api, allpath=False):
if allpath: if allpath:
root = 'unicode1_leadership_requires_disabled_value.' root = 'unicode1_leadership_requires_disabled_value.'
else: else:
root = '' root = ''
await api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2']) api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2'])
await api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1') api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
await api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2') api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
await api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test') api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
await api.option(root + 'options.unicode.unicode2', 1).value.set(u'test') 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.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 return descr
async def get_values(api, allpath=False): def get_values(api, allpath=False):
if allpath: if allpath:
root = 'unicode1_leadership_requires_follower_value.' root = 'unicode1_leadership_requires_follower_value.'
else: else:
root = '' root = ''
await api.option(root + 'options.unicode1.unicode1').value.set([u'test', u'pas test']) 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') 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.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 return descr
async def get_values(api, allpath=False): def get_values(api, allpath=False):
if allpath: if allpath:
root = 'unicode1_leadership_requires_value.' root = 'unicode1_leadership_requires_value.'
else: else:
root = '' root = ''
await api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2']) api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2'])
await api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1') api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
await api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2') api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
await api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test') api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
await api.option(root + 'options.unicode.unicode2', 1).value.set(u'test') 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.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 return descr
async def get_values(api, allpath=False): def get_values(api, allpath=False):
if allpath: if allpath:
root = 'unicode1_leadership_value.' root = 'unicode1_leadership_value.'
else: else:
root = '' root = ''
await api.option(root + 'options.unicode.unicode').value.set([u'val3', u'val4']) api.option(root + 'options.unicode.unicode').value.set([u'val3', u'val4'])
await api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1') api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
await api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2') api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
await api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test') api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
await api.option(root + 'options.unicode.unicode2', 1).value.set(u'test') 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.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 return descr
async def get_values(api, allpath=False): def get_values(api, allpath=False):
if allpath: if allpath:
root = 'unicode1_mod_value.' root = 'unicode1_mod_value.'
else: else:
root = '' 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 return descr
async def get_values(api, allpath=False): def get_values(api, allpath=False):
if allpath: if allpath:
root = 'unicode1_multi_mod_value.' root = 'unicode1_multi_mod_value.'
else: else:
root = '' 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 return ret
async def load_config(filename, def load_config(filename,
add_extra_od=False, add_extra_od=False,
remote='minimum', remote='minimum',
clearable='minimum', clearable='minimum',
@ -46,20 +46,20 @@ async def load_config(filename,
descr = mod.get_description() descr = mod.get_description()
if add_extra_od: if add_extra_od:
descr = OptionDescription('root', '', [descr]) descr = OptionDescription('root', '', [descr])
config = await Config(descr) config = Config(descr)
await config.property.add('demoting_error_warning') config.property.add('demoting_error_warning')
if 'get_values' in dir(mod): if 'get_values' in dir(mod):
await mod.get_values(config, add_extra_od) mod.get_values(config, add_extra_od)
form = [{'title': 'Configurer', form = [{'title': 'Configurer',
'type': 'submit'}] 'type': 'submit'}]
if 'get_form' in dir(mod): if 'get_form' in dir(mod):
form.extend(mod.get_form(add_extra_od)) form.extend(mod.get_form(add_extra_od))
await config.property.read_write() config.property.read_write()
if root is None: 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: 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 return values
@ -150,8 +150,7 @@ def filename_mod(request):
return request.param return request.param
@pytest.mark.asyncio def test_jsons(filename):
async def test_jsons(filename):
debug = False debug = False
# debug = True # debug = True
datadir = datapath() datadir = datapath()
@ -168,7 +167,7 @@ async def test_jsons(filename):
modulepath = splitext(filename)[0] modulepath = splitext(filename)[0]
if debug: if debug:
print(" {} (remote: {}, clearable: {})".format(filename, remote, clearable)) print(" {} (remote: {}, clearable: {})".format(filename, remote, clearable))
values = await load_config(filename, values = load_config(filename,
remote=remote, remote=remote,
clearable=clearable) clearable=clearable)
# #
@ -217,8 +216,7 @@ async def test_jsons(filename):
assert values == expected, "error in file {}".format(filename) assert values == expected, "error in file {}".format(filename)
@pytest.mark.asyncio def test_jsons_subconfig(filename):
async def test_jsons_subconfig(filename):
debug = False debug = False
# debug = True # debug = True
datadir = datapath() datadir = datapath()
@ -227,7 +225,7 @@ async def test_jsons_subconfig(filename):
modulepath = splitext(filename)[0] modulepath = splitext(filename)[0]
if debug: if debug:
print(" ", filename) 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: with open(join(datadir, modulepath + '.json'), 'r') as fh:
expected = loads(fh.read()) expected = loads(fh.read())
@ -292,8 +290,7 @@ async def test_jsons_subconfig(filename):
assert values == expected, "error in file {}".format(filename) assert values == expected, "error in file {}".format(filename)
@pytest.mark.asyncio def test_updates(filename_mod):
async def test_updates(filename_mod):
debug = False debug = False
# debug = True # debug = True
datadir = datapath() datadir = datapath()
@ -362,31 +359,31 @@ async def test_updates(filename_mod):
if debug: if debug:
print(" (remote: {}, clearable: {}, issub {}, root {}, root_path {})".format(remote, clearable, issub, root, root_path)) print(" (remote: {}, clearable: {}, issub {}, root {}, root_path {})".format(remote, clearable, issub, root, root_path))
for with_model in [False, True]: for with_model in [False, True]:
config = await Config(descr) config = Config(descr)
await config.property.add('demoting_error_warning') config.property.add('demoting_error_warning')
if 'get_values' in dir(mod): if 'get_values' in dir(mod):
await mod.get_values(config, issub) mod.get_values(config, issub)
if isfile(join(datadir, modulepath + '.mod')): if isfile(join(datadir, modulepath + '.mod')):
with open(join(datadir, modulepath + '.mod'), 'r') as fh: with open(join(datadir, modulepath + '.mod'), 'r') as fh:
await eval(fh.read()) eval(fh.read())
if dico_ori is None: if dico_ori is None:
if clearable == 'minimum' and remote == 'minimum': if clearable == 'minimum' and remote == 'minimum':
with open(join(datadir, modulepath + '.dict'), 'w') as fh: 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: 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: if root is None:
suboption = config.option suboption = config.option
else: else:
suboption = config.option(root) suboption = config.option(root)
if with_model: if with_model:
bodym = body.copy() 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: else:
await suboption.dict(remotable=remote, clearable=clearable) suboption.dict(remotable=remote, clearable=clearable)
bodym = body bodym = body
if with_model: if with_model:
cal_values = await suboption.updates(bodym) cal_values = suboption.updates(bodym)
if values is None: if values is None:
if clearable == 'minimum' and remote == 'minimum': if clearable == 'minimum' and remote == 'minimum':
with open(join(datadir, modulepath + '.updates{}'.format(idx)), 'w') as fh: with open(join(datadir, modulepath + '.updates{}'.format(idx)), 'w') as fh:
@ -399,10 +396,10 @@ async def test_updates(filename_mod):
pprint(values) pprint(values)
assert cal_values == values assert cal_values == values
else: else:
assert await suboption.updates(bodym) == {} assert suboption.updates(bodym) == {}
if dico_mod is None: if dico_mod is None:
if clearable == 'minimum' and remote == 'minimum': if clearable == 'minimum' and remote == 'minimum':
with open(join(datadir, modulepath + '.dict{}'.format(idx)), 'w') as fh: 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: else:
assert await config.value.dict() == dico_mod assert config.value.dict() == dico_mod

367
tests/test_cache.py
View file

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

306
tests/test_choice_option.py
View file

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

508
tests/test_config.py
View file

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

515
tests/test_config_api.py
View file

@ -1,16 +1,15 @@
"configuration objects global API" "configuration objects global API"
import pytest from pytest import raises
from .autopath import do_autopath from .autopath import do_autopath
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, \ from tiramisu import Config, IntOption, FloatOption, StrOption, ChoiceOption, \
BoolOption, FilenameOption, SymLinkOption, IPOption, \ BoolOption, FilenameOption, SymLinkOption, IPOption, \
PortOption, NetworkOption, NetmaskOption, BroadcastOption, \ PortOption, NetworkOption, NetmaskOption, BroadcastOption, \
DomainnameOption, OptionDescription DomainnameOption, OptionDescription
from tiramisu.error import PropertiesOptionError, ValueWarning from tiramisu.error import PropertiesOptionError, ValueWarning, APIError
from tiramisu.storage import list_sessions
import warnings import warnings
@ -52,50 +51,75 @@ def _is_same_opt(opt1, opt2):
assert opt1 == opt2 assert opt1 == opt2
@pytest.mark.asyncio def test_od_not_list():
async def test_od_not_list():
b = BoolOption('bool', '', multi=True) b = BoolOption('bool', '', multi=True)
with pytest.raises(AssertionError): with raises(AssertionError):
OptionDescription('od', '', b) OptionDescription('od', '', b)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_str():
async def test_str(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg:
cfg # does not crash cfg # does not crash
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_make_dict(config_type):
async def test_make_dict(config_type):
"serialization of the whole config to a dict" "serialization of the whole config to a dict"
descr = OptionDescription("opt", "", [ od1 = OptionDescription("opt", "", [
OptionDescription("s1", "", [ OptionDescription("s1", "", [
BoolOption("a", "", default=False), BoolOption("a", "", default=False),
BoolOption("b", "", default=False, properties=('hidden',))]), BoolOption("b", "", default=False, properties=('hidden',))]),
IntOption("int", "", default=42)]) IntOption("int", "", default=42)])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
await cfg.permissive.add('hidden') cfg.permissive.add('hidden')
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
d = await cfg.value.dict() d = cfg.value.dict()
assert d == {"s1.a": False, "int": 42} assert d == {"s1.a": False, "int": 42}
await cfg.option('int').value.set(43) cfg.option('int').value.set(43)
await cfg.option('s1.a').value.set(True) cfg.option('s1.a').value.set(True)
d = await cfg.value.dict() d = cfg.value.dict()
assert d == {"s1.a": True, "int": 43} 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} assert d2 == {'a': True, 'int': 43}
if config_type == 'tiramisu': if config_type == 'tiramisu':
assert await cfg.forcepermissive.value.dict() == {"s1.a": True, "s1.b": False, "int": 43} assert cfg.forcepermissive.value.dict() == {"s1.a": True, "s1.b": False, "int": 43}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_make_dict_sub(config_type):
async def test_make_dict_with_disabled(config_type): "serialization part of 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)])
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", "", [ OptionDescription("s1", "", [
BoolOption("a", "", default=False), BoolOption("a", "", default=False),
BoolOption("b", "", default=False, properties=('disabled',))]), BoolOption("b", "", default=False, properties=('disabled',))]),
@ -103,19 +127,18 @@ async def test_make_dict_with_disabled(config_type):
BoolOption("a", "", default=False), BoolOption("a", "", default=False),
BoolOption("b", "", default=False)], properties=('disabled',)), BoolOption("b", "", default=False)], properties=('disabled',)),
IntOption("int", "", default=42)]) IntOption("int", "", default=42)])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_only() cfg.property.read_only()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.value.dict() == {"s1.a": False, "int": 42} assert cfg.value.dict() == {"s1.a": False, "int": 42}
if config_type == 'tiramisu': if config_type == 'tiramisu':
assert await cfg.forcepermissive.value.dict() == {"s1.a": False, "int": 42} assert 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 cfg.unrestraint.value.dict() == {"int": 42, "s1.a": False, "s1.b": False, "s2.a": False, "s2.b": False}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_make_dict_with_disabled_in_callback(config_type):
async def test_make_dict_with_disabled_in_callback(config_type): od1 = OptionDescription("opt", "", [
descr = OptionDescription("opt", "", [
OptionDescription("s1", "", [ OptionDescription("s1", "", [
BoolOption("a", "", default=False), BoolOption("a", "", default=False),
BoolOption("b", "", default=False, properties=('disabled',))]), 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("a", "", default=False),
BoolOption("b", "", default=False)], properties=('disabled',)), BoolOption("b", "", default=False)], properties=('disabled',)),
IntOption("int", "", default=42)]) IntOption("int", "", default=42)])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_only() cfg.property.read_only()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
d = await cfg.value.dict() d = cfg.value.dict()
assert d == {"s1.a": False, "int": 42} assert d == {"s1.a": False, "int": 42}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_make_dict_fullpath(config_type):
async def test_make_dict_fullpath(config_type): od1 = OptionDescription("root", "", [
descr = OptionDescription("root", "", [
OptionDescription("opt", "", [ OptionDescription("opt", "", [
OptionDescription("s1", "", [ OptionDescription("s1", "", [
BoolOption("a", "", default=False), BoolOption("a", "", default=False),
@ -143,328 +165,309 @@ async def test_make_dict_fullpath(config_type):
BoolOption("b", "", default=False)], properties=('disabled',)), BoolOption("b", "", default=False)], properties=('disabled',)),
IntOption("int", "", default=42)]), IntOption("int", "", default=42)]),
IntOption("introot", "", default=42)]) IntOption("introot", "", default=42)])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_only() cfg.property.read_only()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.value.dict() == {"opt.s1.a": False, "opt.int": 42, "introot": 42} assert cfg.value.dict() == {"opt.s1.a": False, "opt.int": 42, "introot": 42}
if config_type == 'tiramisu': if config_type == 'tiramisu':
# FIXME # FIXME
assert await cfg.option('opt').value.dict() == {"s1.a": False, "int": 42} assert 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.value.dict(fullpath=True) == {"opt.s1.a": False, "opt.int": 42, "introot": 42}
if config_type == 'tiramisu': if config_type == 'tiramisu':
# FIXME # FIXME
assert await cfg.option('opt').value.dict(fullpath=True) == {"opt.s1.a": False, "opt.int": 42} assert cfg.option('opt').value.dict(fullpath=True) == {"opt.s1.a": False, "opt.int": 42}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_find_in_config():
async def test_find_in_config():
"finds option in config" "finds option in config"
descr = make_description() od1 = make_description()
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_only() cfg.property.read_only()
await cfg.permissive.add('hidden') cfg.permissive.add('hidden')
ret = list(await cfg.option.find('dummy')) ret = list(cfg.option.find('dummy'))
assert len(ret) == 1 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_find = cfg.option.find('dummy', first=True)
ret = await ret_find.option.get() ret = ret_find.option.get()
_is_same_opt(ret, await cfg.option('gc.dummy').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 assert len(ret) == 2
_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())
_is_same_opt(await ret[1].option.get(), await cfg.option('float').option.get()) _is_same_opt(ret[1].option.get(), cfg.option('float').option.get())
# #
ret = await cfg.option.find('bool', first=True) ret = cfg.option.find('bool', first=True)
_is_same_opt(await ret.option.get(), await cfg.option('gc.gc2.bool').option.get()) _is_same_opt(ret.option.get(), cfg.option('gc.gc2.bool').option.get())
ret = await cfg.option.find('bool', value=True, first=True) ret = cfg.option.find('bool', value=True, first=True)
_is_same_opt(await ret.option.get(), await cfg.option('bool').option.get()) _is_same_opt(ret.option.get(), cfg.option('bool').option.get())
ret = await cfg.option.find('dummy', first=True) ret = cfg.option.find('dummy', first=True)
_is_same_opt(await ret.option.get(), await cfg.option('gc.dummy').option.get()) _is_same_opt(ret.option.get(), cfg.option('gc.dummy').option.get())
ret = await cfg.option.find('float', first=True) ret = cfg.option.find('float', first=True)
_is_same_opt(await ret.option.get(), await cfg.option('gc.float').option.get()) _is_same_opt(ret.option.get(), cfg.option('gc.float').option.get())
#FIXME cannot find an option without name ret = list(cfg.option.find('prop'))
#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'))
assert len(ret) == 1 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 assert len(ret) == 1
ret = list(await cfg.option.find('prop')) ret = list(cfg.option.find('prop'))
assert len(ret) == 1 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() cfg.property.read_write()
with pytest.raises(AttributeError): with raises(AttributeError):
ret = await cfg.option.find('prop') ret = cfg.option.find('prop')
assert await ret.option.get() assert ret.option.get()
ret = list(await cfg.unrestraint.option.find(name='prop')) ret = list(cfg.unrestraint.option.find(name='prop'))
assert len(ret) == 2 assert len(ret) == 2
_is_same_opt(await ret[0].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())
_is_same_opt(await ret[1].option.get(), await cfg.forcepermissive.option('gc.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 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) ret = cfg.forcepermissive.option.find('prop', first=True)
_is_same_opt(await ret.option.get(), await cfg.forcepermissive.option('gc.prop').option.get()) _is_same_opt(ret.option.get(), cfg.forcepermissive.option('gc.prop').option.get())
# combinaison of filters # 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 assert len(ret) == 1
_is_same_opt(await ret[0].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 = await cfg.unrestraint.option.find('prop', type=BoolOption, first=True) ret = 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.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 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) ret = cfg.option.find('dummy', value=False, first=True)
_is_same_opt(await ret.option.get(), await cfg.option('gc.dummy').option.get()) _is_same_opt(ret.option.get(), cfg.option('gc.dummy').option.get())
#subcfgig #subcfgig
ret = list(await cfg.option('gc').find('dummy')) ret = list(cfg.option('gc').find('dummy'))
assert len(ret) == 1 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 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 assert len(ret) == 1
_is_same_opt(await ret[0].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 = await cfg.option('gc').find('bool', value=False, first=True) ret = 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.option.get(), cfg.option('gc.gc2.bool').option.get())
# #
with pytest.raises(AttributeError): with raises(AttributeError):
ret = await cfg.option('gc').find('bool', value=True, first=True) ret = cfg.option('gc').find('bool', value=True, first=True)
assert await ret.option.get() assert ret.option.get()
# #
with pytest.raises(AttributeError): with raises(AttributeError):
ret = await cfg.option('gc').find('wantref') ret = cfg.option('gc').find('wantref')
await ret.option.get() ret.option.get()
# #
ret = list(await cfg.unrestraint.option('gc').find('prop')) ret = list(cfg.unrestraint.option('gc').find('prop'))
assert len(ret) == 2 assert len(ret) == 2
_is_same_opt(await ret[0].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())
_is_same_opt(await ret[1].option.get(), await cfg.forcepermissive.option('gc.prop').option.get()) _is_same_opt(ret[1].option.get(), cfg.forcepermissive.option('gc.prop').option.get())
# #
await cfg.property.read_only() cfg.property.read_only()
ret = list(await cfg.option('gc').find('prop')) ret = list(cfg.option('gc').find('prop'))
assert len(ret) == 1 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 # not OptionDescription
with pytest.raises(AttributeError): with raises(AttributeError):
await cfg.option.find('gc', first=True) cfg.option.find('gc', first=True)
with pytest.raises(AttributeError): with raises(AttributeError):
await cfg.option.find('gc2', first=True) cfg.option.find('gc2', first=True)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_find_multi():
async def test_find_multi():
b = BoolOption('bool', '', multi=True, properties=('notunique',)) b = BoolOption('bool', '', multi=True, properties=('notunique',))
o = OptionDescription('od', '', [b]) od1 = OptionDescription('od', '', [b])
async with await Config(o) as cfg: cfg = Config(od1)
# #
with pytest.raises(AttributeError): with raises(AttributeError):
list(await cfg.option.find('bool', value=True)) list(cfg.option.find('bool', value=True))
with pytest.raises(AttributeError): with raises(AttributeError):
list(await cfg.option.find('bool', value=True, first=True)) list(cfg.option.find('bool', value=True, first=True))
await cfg.option('bool').value.set([False]) cfg.option('bool').value.set([False])
with pytest.raises(AttributeError): with raises(AttributeError):
list(await cfg.option.find('bool', value=True)) list(cfg.option.find('bool', value=True))
with pytest.raises(AttributeError): with raises(AttributeError):
list(await cfg.option.find('bool', value=True, first=True)) list(cfg.option.find('bool', value=True, first=True))
await cfg.option('bool').value.set([False, False]) cfg.option('bool').value.set([False, False])
with pytest.raises(AttributeError): with raises(AttributeError):
list(await cfg.option.find('bool', value=True)) list(cfg.option.find('bool', value=True))
with pytest.raises(AttributeError): with raises(AttributeError):
list(await cfg.option.find('bool', value=True, first=True)) list(cfg.option.find('bool', value=True, first=True))
await cfg.option('bool').value.set([False, False, True]) cfg.option('bool').value.set([False, False, True])
ret = list(await cfg.option.find('bool', value=True)) ret = list(cfg.option.find('bool', value=True))
assert len(ret) == 1 assert len(ret) == 1
_is_same_opt(await ret[0].option.get(), b) _is_same_opt(ret[0].option.get(), b)
ret = await cfg.option.find('bool', value=True, first=True) ret = cfg.option.find('bool', value=True, first=True)
_is_same_opt(await ret.option.get(), b) _is_same_opt(ret.option.get(), b)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_does_not_find_in_config():
async def test_does_not_find_in_config(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: with raises(AttributeError):
with pytest.raises(AttributeError): list(cfg.option.find('IDontExist'))
list(await cfg.option.find('IDontExist')) # assert not list_sessions()
assert not await list_sessions()
@pytest.mark.asyncio def test_filename(config_type):
async def test_filename(config_type):
a = FilenameOption('a', '') a = FilenameOption('a', '')
o = OptionDescription('o', '', [a]) od1 = OptionDescription('o', '', [a])
async with await Config(o) as cfg: cfg = Config(od1)
# FIXME cfg = await get_config(cfg, config_type) # FIXME cfg = get_config(cfg, config_type)
await cfg.option('a').value.set('/') cfg.option('a').value.set('/')
await cfg.option('a').value.set('/tmp') cfg.option('a').value.set('/tmp')
await cfg.option('a').value.set('/tmp/') cfg.option('a').value.set('/tmp/')
await cfg.option('a').value.set('/tmp/text.txt') cfg.option('a').value.set('/tmp/text.txt')
await cfg.option('a').value.set('/tmp/with space.txt') cfg.option('a').value.set('/tmp/with space.txt')
await cfg.option('a').value.set('/tmp/with$.txt') cfg.option('a').value.set('/tmp/with$.txt')
with pytest.raises(ValueError): with raises(ValueError):
await cfg.option('a').value.set('not starts with /') cfg.option('a').value.set('not starts with /')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_invalid_option():
async def test_invalid_option():
ChoiceOption('a', '', ('1', '2')) ChoiceOption('a', '', ('1', '2'))
with pytest.raises(TypeError): with raises(TypeError):
ChoiceOption('a', '', [1, 2]) ChoiceOption('a', '', [1, 2])
with pytest.raises(TypeError): with raises(TypeError):
ChoiceOption('a', '', 1) ChoiceOption('a', '', 1)
with pytest.raises(ValueError): with raises(ValueError):
ChoiceOption('a', '', (1,), 3) ChoiceOption('a', '', (1,), 3)
FloatOption('a', '') FloatOption('a', '')
with pytest.raises(ValueError): with raises(ValueError):
FloatOption('a', '', 'string') FloatOption('a', '', 'string')
StrOption('a', '') StrOption('a', '')
with pytest.raises(ValueError): with raises(ValueError):
StrOption('a', '', 1) StrOption('a', '', 1)
u = StrOption('a', '') u = StrOption('a', '')
SymLinkOption('a', u) SymLinkOption('a', u)
with pytest.raises(ValueError): with raises(ValueError):
SymLinkOption('a', 'string') SymLinkOption('a', 'string')
IPOption('a', '') IPOption('a', '')
with pytest.raises(ValueError): with raises(ValueError):
IPOption('a', '', 1) IPOption('a', '', 1)
with pytest.raises(ValueError): with raises(ValueError):
IPOption('a', '', 'string') IPOption('a', '', 'string')
PortOption('a', '') PortOption('a', '')
with pytest.raises(ValueError): with raises(ValueError):
PortOption('a', '', 'string') PortOption('a', '', 'string')
with pytest.raises(ValueError): with raises(ValueError):
PortOption('a', '', '11:12:13', allow_range=True) PortOption('a', '', '11:12:13', allow_range=True)
with pytest.raises(ValueError): with raises(ValueError):
PortOption('a', '', 11111111111111111111) PortOption('a', '', 11111111111111111111)
with pytest.raises(ValueError): with raises(ValueError):
PortOption('a', '', allow_zero=True, allow_wellknown=False, allow_registred=True, allow_private=False) 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) 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) 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) 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) 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') PortOption('a', '', 'tcp:80')
NetworkOption('a', '') NetworkOption('a', '')
with pytest.raises(ValueError): with raises(ValueError):
NetworkOption('a', '', 'string') NetworkOption('a', '', 'string')
NetmaskOption('a', '') NetmaskOption('a', '')
with pytest.raises(ValueError): with raises(ValueError):
NetmaskOption('a', '', 'string') NetmaskOption('a', '', 'string')
BroadcastOption('a', '') BroadcastOption('a', '')
with pytest.raises(ValueError): with raises(ValueError):
BroadcastOption('a', '', 'string') BroadcastOption('a', '', 'string')
DomainnameOption('a', '') DomainnameOption('a', '')
with pytest.raises(ValueError): with raises(ValueError):
DomainnameOption('a', '', 'string') DomainnameOption('a', '', 'string')
with pytest.raises(ValueError): with raises(ValueError):
DomainnameOption('a', '', type='string') DomainnameOption('a', '', type='string')
with pytest.raises(ValueError): with raises(ValueError):
DomainnameOption('a', '', allow_ip='string') DomainnameOption('a', '', allow_ip='string')
with pytest.raises(ValueError): with raises(ValueError):
DomainnameOption('a', '', allow_without_dot='string') DomainnameOption('a', '', allow_without_dot='string')
with pytest.raises(ValueError): with raises(ValueError):
DomainnameOption('a', '', 1) DomainnameOption('a', '', 1)
# #
ChoiceOption('a', '', (1,), multi=True, default_multi=1) ChoiceOption('a', '', (1,), multi=True, default_multi=1)
with pytest.raises(ValueError): with raises(ValueError):
ChoiceOption('a', '', (1,), default_multi=1) ChoiceOption('a', '', (1,), default_multi=1)
with pytest.raises(ValueError): with raises(ValueError):
ChoiceOption('a', '', (1,), multi=True, default=[1,], default_multi=2) ChoiceOption('a', '', (1,), multi=True, default=[1,], default_multi=2)
with pytest.raises(ValueError): with raises(ValueError):
FloatOption('a', '', multi=True, default_multi='string') FloatOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError): with raises(ValueError):
StrOption('a', '', multi=True, default_multi=1) StrOption('a', '', multi=True, default_multi=1)
with pytest.raises(ValueError): with raises(ValueError):
IPOption('a', '', multi=True, default_multi=1) IPOption('a', '', multi=True, default_multi=1)
with pytest.raises(ValueError): with raises(ValueError):
IPOption('a', '', multi=True, default_multi='string') IPOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError): with raises(ValueError):
PortOption('a', '', multi=True, default_multi='string') 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) 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) PortOption('a', '', multi=True, default_multi=11111111111111111111)
with pytest.raises(ValueError): with raises(ValueError):
NetworkOption('a', '', multi=True, default_multi='string') NetworkOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError): with raises(ValueError):
NetmaskOption('a', '', multi=True, default_multi='string') NetmaskOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError): with raises(ValueError):
BroadcastOption('a', '', multi=True, default_multi='string') BroadcastOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError): with raises(ValueError):
DomainnameOption('a', '', multi=True, default_multi='string') DomainnameOption('a', '', multi=True, default_multi='string')
with pytest.raises(ValueError): with raises(ValueError):
DomainnameOption('a', '', multi=True, default_multi=1) DomainnameOption('a', '', multi=True, default_multi=1)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_help():
async def test_help():
stro = StrOption('s', '', multi=True) stro = StrOption('s', '', multi=True)
od1 = OptionDescription('o', '', [stro]) od1 = OptionDescription('o', '', [stro])
od2 = OptionDescription('o', '', [od1]) od2 = OptionDescription('o', '', [od1])
async with await Config(od2) as cfg: cfg = Config(od2)
cfg.help(_display=False) cfg.help(_display=False)
cfg.config.help(_display=False) cfg.config.help(_display=False)
cfg.option.help(_display=False) cfg.option.help(_display=False)
cfg.option('o').help(_display=False) cfg.option('o').help(_display=False)
cfg.option('o.s').help(_display=False) cfg.option('o.s').help(_display=False)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_config_reset():
async def test_config_reset(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.owner.set('test')
await cfg.owner.set('test') assert cfg.owner.get() == 'test'
assert await cfg.owner.get() == 'test' assert not cfg.option('gc.gc2.bool').value.get()
assert not await cfg.option('gc.gc2.bool').value.get() assert not cfg.option('boolop').property.get()
assert not await cfg.option('boolop').property.get() assert not cfg.option('boolop').permissive.get()
assert not await cfg.option('boolop').permissive.get() assert not cfg.option('wantref').information.get('info', None)
assert not await cfg.option('wantref').information.get('info', None)
# #
await cfg.option('gc.gc2.bool').value.set(True) cfg.option('gc.gc2.bool').value.set(True)
await cfg.option('boolop').property.add('test') cfg.option('boolop').property.add('test')
await cfg.option('float').permissive.set(frozenset(['test'])) cfg.option('float').permissive.set(frozenset(['test']))
await cfg.option('wantref').information.set('info', 'info') cfg.option('wantref').information.set('info', 'info')
assert await cfg.option('gc.gc2.bool').value.get() assert cfg.option('gc.gc2.bool').value.get()
assert await cfg.option('boolop').property.get() assert cfg.option('boolop').property.get()
assert await cfg.option('float').permissive.get() assert cfg.option('float').permissive.get()
assert await cfg.option('wantref').information.get('info', None) assert cfg.option('wantref').information.get('info', None)
# #
assert await cfg.owner.get() == 'test' assert cfg.owner.get() == 'test'
await cfg.config.reset() cfg.config.reset()
assert await cfg.owner.get() == 'test' assert cfg.owner.get() == 'test'
assert not await cfg.option('gc.gc2.bool').value.get() assert not cfg.option('gc.gc2.bool').value.get()
assert not await cfg.option('boolop').property.get() assert not cfg.option('boolop').property.get()
assert not await cfg.option('float').permissive.get() assert not cfg.option('float').permissive.get()
assert not await cfg.option('wantref').information.get('info', None) assert not cfg.option('wantref').information.get('info', None)
assert not await list_sessions() # 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 import Config, DomainnameOption, EmailOption, URLOption, OptionDescription
from tiramisu.error import ValueWarning from tiramisu.error import ValueWarning
from tiramisu.i18n import _ from tiramisu.i18n import _
from tiramisu.storage import list_sessions
from .config import event_loop
@pytest.mark.asyncio def test_domainname(config_type):
async def test_domainname(config_type):
d = DomainnameOption('d', '') d = DomainnameOption('d', '')
f = DomainnameOption('f', '', allow_without_dot=True) f = DomainnameOption('f', '', allow_without_dot=True)
g = DomainnameOption('g', '', allow_ip=True) g = DomainnameOption('g', '', allow_ip=True)
h = DomainnameOption('h', '', allow_cidr_network=True) h = DomainnameOption('h', '', allow_cidr_network=True)
od = OptionDescription('a', '', [d, f, g, h]) i = DomainnameOption('i', '', allow_ip=True, allow_cidr_network=True)
async with await Config(od) as cfg: j = DomainnameOption('j', '', allow_startswith_dot=True)
await cfg.property.read_write() od1 = OptionDescription('a', '', [d, f, g, h, i, j])
cfg = await get_config(cfg, config_type) 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): with pytest.raises(ValueError):
await cfg.option('d').value.set('toto') cfg.option('d').value.set('.toto.com')
await cfg.option('d').value.set('toto3.com')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('d').value.set('toto_super.com') cfg.option('d').value.set('toto')
await cfg.option('d').value.set('toto-.com') cfg.option('d').value.set('toto3.com')
with pytest.raises(ValueError): 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') cfg.option('f').value.set('toto.com')
await cfg.option('f').value.set('toto') cfg.option('f').value.set('toto')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea') cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamean') cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamean')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nd') cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nd')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie') cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('d').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowien') cfg.option('d').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowien')
await cfg.option('f').value.set('d') cfg.option('f').value.set('d')
await cfg.option('f').value.set('d.t') cfg.option('f').value.set('d.t')
# #
if config_type != 'tiramisu-api': if config_type != 'tiramisu-api':
# FIXME # FIXME
with pytest.raises(ValueError): 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): 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') cfg.option('g').value.set('toto.com')
await cfg.option('g').value.set('192.168.1.0') cfg.option('g').value.set('192.168.1.0')
await cfg.option('g').value.set('192.168.1.29') cfg.option('g').value.set('192.168.1.29')
with pytest.raises(ValueError): 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': if config_type != 'tiramisu-api':
# FIXME # FIXME
with pytest.raises(ValueError): 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): 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 # 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 # but not here
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('h').value.set('192.168.1.1/24') cfg.option('h').value.set('192.168.1.1/24')
assert not await list_sessions() #
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 def test_domainname_invalid(config_type):
async def test_domainname_upper(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', '') d = DomainnameOption('d', '')
od = OptionDescription('a', '', [d]) od1 = OptionDescription('a', '', [d])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
await cfg.option('d').value.set('toto.com') cfg.option('d').value.set('toto.com')
msg = _('some characters are uppercase') msg = _('some characters are uppercase')
has_error = False has_error = False
try: try:
await cfg.option('d').value.set('TOTO.COM') cfg.option('d').value.set('TOTO.COM')
except ValueError as err: except ValueError as err:
if config_type != 'tiramisu-api': if config_type != 'tiramisu-api':
# FIXME # FIXME
@ -93,171 +113,165 @@ async def test_domainname_upper(config_type):
assert has_error is True assert has_error is True
has_error = False has_error = False
try: try:
await cfg.option('d').value.set('toTo.com') cfg.option('d').value.set('toTo.com')
except ValueError as err: except ValueError as err:
if config_type != 'tiramisu-api': if config_type != 'tiramisu-api':
# FIXME # FIXME
assert msg in str(err) assert msg in str(err)
has_error = True has_error = True
assert has_error is True assert has_error is True
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_domainname_warning(config_type):
async def test_domainname_warning(config_type):
d = DomainnameOption('d', '', warnings_only=True) d = DomainnameOption('d', '', warnings_only=True)
f = DomainnameOption('f', '', allow_without_dot=True, warnings_only=True) f = DomainnameOption('f', '', allow_without_dot=True, warnings_only=True)
g = DomainnameOption('g', '', allow_ip=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) warnings.simplefilter("always", ValueWarning)
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
await cfg.option('d').value.set('toto.com') cfg.option('d').value.set('toto.com')
await cfg.option('d').value.set('toto.com.') cfg.option('d').value.set('toto.com.')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('d').value.set('toto') cfg.option('d').value.set('toto')
await cfg.option('d').value.set('toto3.com') cfg.option('d').value.set('toto3.com')
if config_type != 'tiramisu-api': if config_type != 'tiramisu-api':
# FIXME # FIXME
with warnings.catch_warnings(record=True) as w: 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 assert len(w) == 1
with warnings.catch_warnings(record=True) as w: 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 assert len(w) == 0
with pytest.raises(ValueError): 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') cfg.option('f').value.set('toto.com')
await cfg.option('f').value.set('toto') cfg.option('f').value.set('toto')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea') cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamean') cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamean')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nd') cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nd')
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie') cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainnamea.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnameto.olongthathavemorethanmaximumsizeforatruedomainnameanditsnoteas.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie')
if config_type != 'tiramisu-api': if config_type != 'tiramisu-api':
# FIXME # FIXME
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainname.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnamet.olongthathavemorethanmaximumsizeforatruedomainnameanditsnotea.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie.xxxx') cfg.option('f').value.set('domainnametoolongthathavemorethanmaximumsizeforatruedomainname.nditsnoteasytogeneratesolongdomainnamewithoutrepeatdomainnamet.olongthathavemorethanmaximumsizeforatruedomainnameanditsnotea.ytogeneratesolongdomainnamewithoutrepeatbutimnotabletodoitnowie.xxxx')
await cfg.option('f').value.set('d') cfg.option('f').value.set('d')
await cfg.option('f').value.set('d.t') cfg.option('f').value.set('d.t')
# #
if config_type != 'tiramisu-api': if config_type != 'tiramisu-api':
# FIXME # FIXME
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('f').value.set('192.168.1.1') cfg.option('f').value.set('192.168.1.1')
await cfg.option('g').value.set('toto.com') cfg.option('g').value.set('toto.com')
await cfg.option('g').value.set('192.168.1.0') cfg.option('g').value.set('192.168.1.0')
await cfg.option('g').value.set('192.168.1.29') cfg.option('g').value.set('192.168.1.29')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_special_domain_name(config_type):
async def test_special_domain_name(config_type):
"""domain name option that starts with a number or not """domain name option that starts with a number or not
""" """
d = DomainnameOption('d', '') d = DomainnameOption('d', '')
e = DomainnameOption('e', '', type='netbios') e = DomainnameOption('e', '', type='netbios')
od = OptionDescription('a', '', [d, e]) od1 = OptionDescription('a', '', [d, e])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
await cfg.option('d').value.set('1toto.com') cfg.option('d').value.set('1toto.com')
await cfg.option('d').value.set('123toto.com') cfg.option('d').value.set('123toto.com')
await cfg.option('e').value.set('toto') cfg.option('e').value.set('toto')
await cfg.option('e').value.set('1toto') cfg.option('e').value.set('1toto')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_domainname_netbios(config_type):
async def test_domainname_netbios(config_type):
d = DomainnameOption('d', '', type='netbios') d = DomainnameOption('d', '', type='netbios')
e = DomainnameOption('e', '', "toto", type='netbios') e = DomainnameOption('e', '', "toto", type='netbios')
od = OptionDescription('a', '', [d, e]) od1 = OptionDescription('a', '', [d, e])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('d').value.set('toto.com') cfg.option('d').value.set('toto.com')
await cfg.option('d').value.set('toto') cfg.option('d').value.set('toto')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('d').value.set('domainnametoolong') cfg.option('d').value.set('domainnametoolong')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_domainname_hostname(config_type):
async def test_domainname_hostname(config_type):
d = DomainnameOption('d', '', type='hostname') d = DomainnameOption('d', '', type='hostname')
e = DomainnameOption('e', '', "toto", type='hostname') e = DomainnameOption('e', '', "toto", type='hostname')
od = OptionDescription('a', '', [d, e]) od1 = OptionDescription('a', '', [d, e])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('d').value.set('toto.com') cfg.option('d').value.set('toto.com')
await cfg.option('d').value.set('toto') cfg.option('d').value.set('toto')
await cfg.option('d').value.set('domainnametoolong') cfg.option('d').value.set('domainnametoolong')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_email(config_type):
async def test_email(config_type):
e = EmailOption('e', '') e = EmailOption('e', '')
od = OptionDescription('a', '', [e]) od1 = OptionDescription('a', '', [e])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
await cfg.option('e').value.set('foo-bar.baz@example.com') cfg.option('e').value.set('foo-bar.baz@example.com')
await cfg.option('e').value.set('root@foo.com') cfg.option('e').value.set('root@foo.com')
await cfg.option('e').value.set('root@domain') cfg.option('e').value.set('root@domain')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('e').value.set(1) cfg.option('e').value.set(1)
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('e').value.set('root') cfg.option('e').value.set('root')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('e').value.set('root[]@domain') cfg.option('e').value.set('root[]@domain')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_url(config_type):
async def test_url(config_type):
u = URLOption('u', '') u = URLOption('u', '')
od = OptionDescription('a', '', [u]) od1 = OptionDescription('a', '', [u])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
await cfg.option('u').value.set('http://foo.com') cfg.option('u').value.set('http://foo.com')
await cfg.option('u').value.set('https://foo.com') cfg.option('u').value.set('https://foo.com')
await cfg.option('u').value.set('https://foo.com/') cfg.option('u').value.set('https://foo.com/')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('u').value.set(1) cfg.option('u').value.set(1)
if config_type != 'tiramisu-api': if config_type != 'tiramisu-api':
# FIXME # FIXME
with pytest.raises(ValueError): 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): with pytest.raises(ValueError):
await cfg.option('u').value.set('foo.com') cfg.option('u').value.set('foo.com')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('u').value.set(':/foo.com') cfg.option('u').value.set(':/foo.com')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('u').value.set('foo.com/http://') cfg.option('u').value.set('foo.com/http://')
await cfg.option('u').value.set('https://foo.com/index.html') 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('https://foo.com/index.html?var=value&var2=val2')
if config_type != 'tiramisu-api': if config_type != 'tiramisu-api':
# FIXME # FIXME
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('u').value.set('https://foo.com/index\\n.html') cfg.option('u').value.set('https://foo.com/index\\n.html')
await cfg.option('u').value.set('https://foo.com:8443') cfg.option('u').value.set('https://foo.com:8443')
await cfg.option('u').value.set('https://foo.com:8443/') 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:8443/index.html')
if config_type != 'tiramisu-api': if config_type != 'tiramisu-api':
# FIXME # FIXME
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('u').value.set('https://foo.com:84438989') 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:8443/INDEX')
if config_type != 'tiramisu-api': if config_type != 'tiramisu-api':
# FIXME # FIXME
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('u').value.set('https://FOO.COM:8443') cfg.option('u').value.set('https://FOO.COM:8443')
assert not await list_sessions() # assert not list_sessions()

463
tests/test_config_ip.py
View file

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

134
tests/test_dereference.py
View file

@ -7,64 +7,40 @@ import pytest
from tiramisu import BoolOption, IntOption, StrOption, IPOption, NetmaskOption, \ from tiramisu import BoolOption, IntOption, StrOption, IPOption, NetmaskOption, \
SymLinkOption, OptionDescription, DynOptionDescription, submulti, \ SymLinkOption, OptionDescription, DynOptionDescription, submulti, \
Config, GroupConfig, MetaConfig, Params, ParamOption, Calculation Config, GroupConfig, MetaConfig, Params, ParamOption, Calculation
from tiramisu.storage import list_sessions
from .config import event_loop
IS_DEREFABLE = True
def funcname(*args, **kwargs): def funcname(*args, **kwargs):
return value return value
@pytest.mark.asyncio def test_deref_value():
async def test_deref_storage():
b = BoolOption('b', '') b = BoolOption('b', '')
o = OptionDescription('od', '', [b]) o = OptionDescription('od', '', [b])
async with await Config(o) as cfg: cfg = Config(o)
w = weakref.ref(cfg._config_bag.context.cfgimpl_get_values()._p_)
del cfg
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async 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()) w = weakref.ref(cfg._config_bag.context.cfgimpl_get_values())
del cfg del cfg
assert w() is None assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_setting():
async def test_deref_setting():
b = BoolOption('b', '') b = BoolOption('b', '')
o = OptionDescription('od', '', [b]) o = OptionDescription('od', '', [b])
async with await Config(o) as cfg: cfg = Config(o)
w = weakref.ref(cfg._config_bag.context.cfgimpl_get_settings()) w = weakref.ref(cfg._config_bag.context.cfgimpl_get_settings())
del cfg del cfg
assert w() is None assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_config():
async def test_deref_config():
b = BoolOption('b', '') b = BoolOption('b', '')
o = OptionDescription('od', '', [b]) o = OptionDescription('od', '', [b])
async with await Config(o) as cfg: cfg = Config(o)
w = weakref.ref(cfg) w = weakref.ref(cfg)
del cfg del cfg
assert w() is None assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_option():
async def test_deref_option():
global IS_DEREFABLE
b = BoolOption('b', '') b = BoolOption('b', '')
o = OptionDescription('od', '', [b]) o = OptionDescription('od', '', [b])
w = weakref.ref(b) w = weakref.ref(b)
@ -72,17 +48,12 @@ async def test_deref_option():
try: try:
assert w() is not None assert w() is not None
except AssertionError: except AssertionError:
IS_DEREFABLE = False
return return
del(o) del(o)
assert w() is None assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_optiondescription():
async def test_deref_optiondescription():
if not IS_DEREFABLE:
return
b = BoolOption('b', '') b = BoolOption('b', '')
o = OptionDescription('od', '', [b]) o = OptionDescription('od', '', [b])
w = weakref.ref(o) w = weakref.ref(o)
@ -90,46 +61,34 @@ async def test_deref_optiondescription():
assert w() is not None assert w() is not None
del(o) del(o)
assert w() is None assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_option_cache():
async def test_deref_option_cache():
if not IS_DEREFABLE:
return
b = BoolOption('b', '') b = BoolOption('b', '')
o = OptionDescription('od', '', [b]) o = OptionDescription('od', '', [b])
await o._build_cache() o._build_cache()
w = weakref.ref(b) w = weakref.ref(b)
del(b) del(b)
assert w() is not None assert w() is not None
del(o) del(o)
assert w() is None assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_optiondescription_cache():
async def test_deref_optiondescription_cache():
if not IS_DEREFABLE:
return
b = BoolOption('b', '') b = BoolOption('b', '')
o = OptionDescription('od', '', [b]) o = OptionDescription('od', '', [b])
await o._build_cache() o._build_cache()
w = weakref.ref(o) w = weakref.ref(o)
del(b) del(b)
assert w() is not None assert w() is not None
del(o) del(o)
assert w() is None assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_option_config():
async def test_deref_option_config():
if not IS_DEREFABLE:
return
b = BoolOption('b', '') b = BoolOption('b', '')
o = OptionDescription('od', '', [b]) o = OptionDescription('od', '', [b])
async with await Config(o) as cfg: cfg = Config(o)
w = weakref.ref(b) w = weakref.ref(b)
del(b) del(b)
assert w() is not None assert w() is not None
@ -137,16 +96,12 @@ async def test_deref_option_config():
assert w() is not None assert w() is not None
del cfg del cfg
assert w() is None assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_optiondescription_config():
async def test_deref_optiondescription_config():
if not IS_DEREFABLE:
return
b = BoolOption('b', '') b = BoolOption('b', '')
o = OptionDescription('od', '', [b]) o = OptionDescription('od', '', [b])
async with await Config(o) as cfg: cfg = Config(o)
w = weakref.ref(o) w = weakref.ref(o)
del(b) del(b)
assert w() is not None assert w() is not None
@ -154,20 +109,16 @@ async def test_deref_optiondescription_config():
assert w() is not None assert w() is not None
del cfg del cfg
assert w() is None assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_validator():
async def test_deref_validator():
if not IS_DEREFABLE:
return
a = StrOption('a', '', default='yes') a = StrOption('a', '', default='yes')
b = StrOption('b', '', validators=[Calculation(funcname, Params(ParamOption(a)))], default='val') b = StrOption('b', '', validators=[Calculation(funcname, Params(ParamOption(a)))], default='val')
od = OptionDescription('root', '', [a, b]) o = OptionDescription('root', '', [a, b])
async with await Config(od) as cfg: cfg = Config(o)
w = weakref.ref(a) w = weakref.ref(a)
x = weakref.ref(b) x = weakref.ref(b)
y = weakref.ref(od) y = weakref.ref(o)
z = weakref.ref(cfg) z = weakref.ref(cfg)
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
@ -179,7 +130,7 @@ async def test_deref_validator():
assert x() is not None assert x() is not None
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
del(od) del(o)
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
assert w() is not None assert w() is not None
@ -187,20 +138,16 @@ async def test_deref_validator():
del cfg del cfg
assert y() is None assert y() is None
assert z() is None assert z() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_callback():
async def test_deref_callback():
if not IS_DEREFABLE:
return
a = StrOption('a', "", 'val') a = StrOption('a', "", 'val')
b = StrOption('b', "", Calculation(funcname, Params((ParamOption(a),)))) b = StrOption('b', "", Calculation(funcname, Params((ParamOption(a),))))
od = OptionDescription('root', '', [a, b]) o = OptionDescription('root', '', [a, b])
async with await Config(od) as cfg: cfg = Config(o)
w = weakref.ref(a) w = weakref.ref(a)
x = weakref.ref(b) x = weakref.ref(b)
y = weakref.ref(od) y = weakref.ref(o)
z = weakref.ref(cfg) z = weakref.ref(cfg)
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
@ -212,7 +159,7 @@ async def test_deref_callback():
assert x() is not None assert x() is not None
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
del(od) del(o)
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
assert w() is not None assert w() is not None
@ -220,20 +167,16 @@ async def test_deref_callback():
del cfg del cfg
assert y() is None assert y() is None
assert z() is None assert z() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_symlink():
async def test_deref_symlink():
if not IS_DEREFABLE:
return
a = BoolOption("a", "", default=False) a = BoolOption("a", "", default=False)
b = SymLinkOption("b", a) b = SymLinkOption("b", a)
od = OptionDescription('root', '', [a, b]) o = OptionDescription('root', '', [a, b])
async with await Config(od) as cfg: cfg = Config(o)
w = weakref.ref(a) w = weakref.ref(a)
x = weakref.ref(b) x = weakref.ref(b)
y = weakref.ref(od) y = weakref.ref(o)
z = weakref.ref(cfg) z = weakref.ref(cfg)
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
@ -245,7 +188,7 @@ async def test_deref_symlink():
assert x() is not None assert x() is not None
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
del(od) del(o)
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
assert w() is not None assert w() is not None
@ -253,21 +196,17 @@ async def test_deref_symlink():
del cfg del cfg
assert y() is None assert y() is None
assert z() is None assert z() is None
assert not await list_sessions()
@pytest.mark.asyncio def test_deref_dyn():
async def test_deref_dyn():
if not IS_DEREFABLE:
return
a = StrOption('a', '', ['val1', 'val2'], multi=True) a = StrOption('a', '', ['val1', 'val2'], multi=True)
b = StrOption('b', '') b = StrOption('b', '')
dod = DynOptionDescription('dod', '', [b], suffixes=Calculation(funcname, Params((ParamOption(a),)))) dod = DynOptionDescription('dod', '', [b], suffixes=Calculation(funcname, Params((ParamOption(a),))))
od = OptionDescription('od', '', [dod, a]) o = OptionDescription('od', '', [dod, a])
async with await Config(od) as cfg: cfg = Config(o)
w = weakref.ref(a) w = weakref.ref(a)
x = weakref.ref(b) x = weakref.ref(b)
y = weakref.ref(od) y = weakref.ref(o)
z = weakref.ref(cfg) z = weakref.ref(cfg)
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
@ -279,7 +218,7 @@ async def test_deref_dyn():
assert x() is not None assert x() is not None
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
del(od) del(o)
del(dod) del(dod)
assert w() is not None assert w() is not None
assert x() is not None assert x() is not None
@ -288,4 +227,3 @@ async def test_deref_dyn():
del cfg del cfg
assert y() is None assert y() is None
assert z() 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.setting import groups
from tiramisu import Config, MetaConfig, ChoiceOption, BoolOption, IntOption, \ from tiramisu import Config, MetaConfig, ChoiceOption, BoolOption, IntOption, \
StrOption, OptionDescription, groups StrOption, OptionDescription, groups
from tiramisu.storage import list_sessions
from .config import event_loop
def make_description(): def make_description():
@ -43,62 +41,54 @@ def make_description():
return descr return descr
def to_tuple(val): def test_copy():
return tuple([tuple(v) for v in val]) 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 def test_copy_information():
async def test_copy(): od1 = make_description()
od = make_description() cfg = Config(od1)
async with await Config(od) as cfg: cfg.information.set('key', 'value')
async with await cfg.config.copy() as ncfg: ncfg = cfg.config.copy()
assert await cfg.option('creole.general.numero_etab').value.get() == None assert ncfg.information.get('key') == 'value'
await cfg.option('creole.general.numero_etab').value.set('oui') # assert not list_sessions()
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()
@pytest.mark.asyncio def test_copy_force_store_value():
async def test_copy_information(): od1 = make_description()
od = make_description() conf = Config(od1)
async with await Config(od) as cfg: conf2 = Config(od1)
await cfg.information.set('key', 'value') assert conf.value.exportation() == {}
async with await cfg.config.copy() as ncfg: assert conf2.value.exportation() == {}
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()) == ((), (), (), ())
# #
await conf.property.read_write() conf.property.read_write()
assert to_tuple(await conf.value.exportation()) == (('creole.general.wantref',), (None,), (False,), ('forced',)) assert conf.value.exportation() == {'creole.general.wantref': {None: [False, 'forced']}}
assert to_tuple(await conf2.value.exportation()) == ((), (), (), ()) assert conf2.value.exportation() == {}
# #
await conf2.property.read_only() conf2.property.read_only()
assert to_tuple(await conf.value.exportation()) == (('creole.general.wantref',), (None,), (False,), ('forced',)) assert conf.value.exportation() == {'creole.general.wantref': {None: [False, 'forced']}}
assert to_tuple(await conf2.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) conf.option('creole.general.wantref').value.set(True)
assert to_tuple(await conf.value.exportation()) == (('creole.general.wantref',), (None,), (True,), ('user',)) assert conf.value.exportation() == {'creole.general.wantref': {None: [True, 'user']}}
assert to_tuple(await conf2.value.exportation()) == (('creole.general.wantref',), (None,), (False,), ('forced',)) assert conf2.value.exportation() == {'creole.general.wantref': {None: [False, 'forced']}}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_copy_force_store_value_metaconfig():
async def test_copy_force_store_value_metaconfig(): od1 = make_description()
descr = make_description() meta = MetaConfig([], optiondescription=od1)
async with await MetaConfig([], optiondescription=descr) as meta: conf = meta.config.new()
async with await meta.config.new(session_id='conf') as conf: assert meta.property.get() == conf.property.get()
assert await meta.property.get() == await conf.property.get() assert meta.permissive.get() == conf.permissive.get()
assert await meta.permissive.get() == await conf.permissive.get() conf.property.read_write()
await conf.property.read_write() assert conf.value.exportation() == {'creole.general.wantref': {None: [False, 'forced']}}
assert to_tuple(await conf.value.exportation()) == (('creole.general.wantref',), (None,), (False,), ('forced',)) assert meta.value.exportation() == {}
assert to_tuple(await meta.value.exportation()) == ((), (), (), ()) # assert not list_sessions()
assert not await 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.setting import owners, groups
from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \ from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
StrOption, OptionDescription, SymLinkOption, Leadership, Config, \ 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.error import PropertiesOptionError, ConfigError
from tiramisu.storage import list_sessions
from .config import event_loop
def compare(calculated, expected): def compare(calculated, expected):
def convert_list(val): assert calculated == expected
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]
#____________________________________________________________ #____________________________________________________________
@ -76,151 +66,151 @@ def return_val3(context, value):
return value return value
@pytest.mark.asyncio def test_freeze_whole_config():
async def test_freeze_whole_config(): od1 = make_description_freeze()
descr = make_description_freeze() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write() cfg.property.add('everything_frozen')
await cfg.property.add('everything_frozen') assert cfg.option('gc.dummy').value.get() is False
assert await cfg.option('gc.dummy').value.get() is False
prop = [] prop = []
try: try:
await cfg.option('gc.dummy').value.set(True) cfg.option('gc.dummy').value.set(True)
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'frozen' in prop 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') cfg.property.remove('everything_frozen')
await cfg.option('gc.dummy').value.set(True) cfg.option('gc.dummy').value.set(True)
assert await cfg.option('gc.dummy').value.get() is True assert cfg.option('gc.dummy').value.get() is True
# #
await cfg.property.add('everything_frozen') cfg.property.add('everything_frozen')
owners.addowner("everythingfrozen2") owners.addowner("everythingfrozen2")
prop = [] prop = []
try: try:
await cfg.option('gc.dummy').owner.set('everythingfrozen2') cfg.option('gc.dummy').owner.set('everythingfrozen2')
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'frozen' in prop assert 'frozen' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_freeze_one_option():
async def test_freeze_one_option():
"freeze an option " "freeze an option "
descr = make_description_freeze() od1 = make_description_freeze()
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
#freeze only one option #freeze only one option
await cfg.option('gc.dummy').property.add('frozen') cfg.option('gc.dummy').property.add('frozen')
assert await cfg.option('gc.dummy').value.get() is False assert cfg.option('gc.dummy').value.get() is False
prop = [] prop = []
try: try:
await cfg.option('gc.dummy').value.set(True) cfg.option('gc.dummy').value.set(True)
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'frozen' in prop assert 'frozen' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_frozen_value():
async def test_frozen_value():
"setattr a frozen value at the config level" "setattr a frozen value at the config level"
s = StrOption("string", "", default="string") s = StrOption("string", "", default="string")
descr = OptionDescription("options", "", [s]) od1 = OptionDescription("options", "", [s])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
await cfg.property.add('frozen') cfg.property.add('frozen')
await cfg.option('string').property.add('frozen') cfg.option('string').property.add('frozen')
prop = [] prop = []
try: try:
await cfg.option('string').value.set('egg') cfg.option('string').value.set('egg')
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'frozen' in prop assert 'frozen' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_freeze():
async def test_freeze():
"freeze a whole configuration object" "freeze a whole configuration object"
descr = make_description_freeze() od1 = make_description_freeze()
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
await cfg.property.add('frozen') cfg.property.add('frozen')
await cfg.option('gc.name').property.add('frozen') cfg.option('gc.name').property.add('frozen')
prop = [] prop = []
try: try:
await cfg.option('gc.name').value.set('framework') cfg.option('gc.name').value.set('framework')
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'frozen' in prop assert 'frozen' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_freeze_multi():
async def test_freeze_multi(): od1 = make_description_freeze()
descr = make_description_freeze() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write() cfg.property.add('frozen')
await cfg.property.add('frozen') cfg.option('boolop').property.add('frozen')
await cfg.option('boolop').property.add('frozen')
prop = [] prop = []
try: try:
await cfg.option('boolop').value.set([True]) cfg.option('boolop').value.set([True])
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'frozen' in prop assert 'frozen' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_force_store_value():
async def test_force_store_value(): od1 = make_description_freeze()
descr = make_description_freeze() cfg = Config(od1)
async with await Config(descr) as cfg: compare(cfg.value.exportation(), {})
compare(await cfg.value.exportation(), (('wantref', 'wantref2', 'wantref3'), (None, None, None), (False, False, (False,)), ('forced', 'forced', 'forced'))) cfg.property.read_write()
await cfg.option('wantref').value.set(True) compare(cfg.value.exportation(), {'wantref': {None: [False, 'forced']}, 'wantref2': {None: [False, 'forced']}, 'wantref3': {None: [[False], 'forced']}})
compare(await cfg.value.exportation(), (('wantref', 'wantref2', 'wantref3'), (None, None, None), (True, False, (False,)), ('user', 'forced', 'forced'))) cfg.option('bool').value.set(False)
await cfg.option('wantref').value.reset() cfg.option('wantref').value.set(True)
compare(await cfg.value.exportation(), (('wantref', 'wantref2', 'wantref3'), (None, None, None), (False, False, (False,)), ('forced', 'forced', 'forced'))) cfg.option('bool').value.reset()
assert not await list_sessions() 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 def test_force_store_value_leadership_sub():
async def test_force_store_value_leadership_sub():
b = IntOption('int', 'Test int option', multi=True, properties=('force_store_value',)) b = IntOption('int', 'Test int option', multi=True, properties=('force_store_value',))
c = StrOption('str', 'Test string option', multi=True) c = StrOption('str', 'Test string option', multi=True)
descr = Leadership("int", "", [b, c]) descr = Leadership("int", "", [b, c])
odr = OptionDescription('odr', '', [descr]) od1 = OptionDescription('odr', '', [descr])
async with await Config(odr) as cfg: cfg = Config(od1)
compare(await cfg.value.exportation(), (('int.int',), (None,), (tuple(),), ('forced',))) cfg.property.read_only()
assert not await list_sessions() compare(cfg.value.exportation(), {'int.int': {None: [[], 'forced']}})
# assert not list_sessions()
@pytest.mark.asyncio def test_force_store_value_callback():
async def test_force_store_value_callback():
b = IntOption('int', 'Test int option', Calculation(return_val), properties=('force_store_value',)) b = IntOption('int', 'Test int option', Calculation(return_val), properties=('force_store_value',))
descr = OptionDescription("int", "", [b]) od1 = OptionDescription("int", "", [b])
async with await Config(descr) as cfg: cfg = Config(od1)
compare(await cfg.value.exportation(), (('int',), (None,), (1,), ('forced',))) cfg.property.read_only()
assert not await list_sessions() compare(cfg.value.exportation(), {'int': {None: [1, 'forced']}})
# assert not list_sessions()
@pytest.mark.asyncio def test_force_store_value_callback_params():
async 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',)) b = IntOption('int', 'Test int option', Calculation(return_val2, Params(kwargs={'value': ParamValue(2)})), properties=('force_store_value',))
descr = OptionDescription("int", "", [b]) od1 = OptionDescription("int", "", [b])
async with await Config(descr) as cfg: cfg = Config(od1)
compare(await cfg.value.exportation(), (('int',), (None,), (2,), ('forced',))) cfg.property.read_only()
assert not await list_sessions() compare(cfg.value.exportation(), {'int': {None: [2, 'forced']}})
# assert not list_sessions()
@pytest.mark.asyncio def test_force_store_value_callback_params_with_opt():
async def test_force_store_value_callback_params_with_opt():
a = IntOption('val1', "", 2) a = IntOption('val1', "", 2)
b = IntOption('int', 'Test int option', Calculation(return_val2, Params(kwargs={'value': ParamOption(a)})), properties=('force_store_value',)) b = IntOption('int', 'Test int option', Calculation(return_val2, Params(kwargs={'value': ParamOption(a)})), properties=('force_store_value',))
descr = OptionDescription("int", "", [a, b]) od1 = OptionDescription("int", "", [a, b])
async with await Config(descr) as cfg: cfg = Config(od1)
compare(await cfg.value.exportation(), (('int',), (None,), (2,), ('forced',))) cfg.property.read_only()
assert not await list_sessions() 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 ParamOption, ParamValue, calc_value
from tiramisu.error import PropertiesOptionError, ConfigError from tiramisu.error import PropertiesOptionError, ConfigError
from tiramisu.setting import groups from tiramisu.setting import groups
from tiramisu.storage import list_sessions
from .config import event_loop
#def teardown_function(function): #def teardown_function(function):
@ -76,533 +74,514 @@ def make_description3():
return descr return descr
@pytest.mark.asyncio def test_mandatory_ro():
async def test_mandatory_ro(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_only()
await cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('str1').value.get() cfg.option('str1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str1').value.set('yes') cfg.option('str1').value.set('yes')
await cfg.property.read_only() cfg.property.read_only()
assert await cfg.option('str1').value.get() == 'yes' assert cfg.option('str1').value.get() == 'yes'
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_ro_dict():
async def test_mandatory_ro_dict(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_only()
await cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.value.dict() cfg.value.dict()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str1').value.set('yes') cfg.option('str1').value.set('yes')
await cfg.option('unicode2').value.set('yes') cfg.option('unicode2').value.set('yes')
await cfg.property.read_only() cfg.property.read_only()
try: try:
await cfg.value.dict() cfg.value.dict()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str3').value.set(['yes']) cfg.option('str3').value.set(['yes'])
await cfg.property.read_only() cfg.property.read_only()
assert await cfg.value.dict() == {'str': 'abc', 'str1': 'yes', 'str3': ['yes'], 'unicode2': 'yes'} assert cfg.value.dict() == {'str': 'abc', 'str1': 'yes', 'str3': ['yes'], 'unicode2': 'yes'}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_rw():
async def test_mandatory_rw(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write()
# not mandatory in rw # not mandatory in rw
await cfg.option('str1').value.get() cfg.option('str1').value.get()
await cfg.option('str1').value.set('yes') cfg.option('str1').value.set('yes')
assert await cfg.option('str1').value.get() == 'yes' assert cfg.option('str1').value.get() == 'yes'
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_default():
async def test_mandatory_default(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_only()
await cfg.property.read_only()
#not mandatory in rw #not mandatory in rw
await cfg.option('str').value.get() cfg.option('str').value.get()
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str').value.set('yes') cfg.option('str').value.set('yes')
await cfg.property.read_only() cfg.property.read_only()
await cfg.option('str').value.get() cfg.option('str').value.get()
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str').value.set(None) cfg.option('str').value.set(None)
await cfg.property.read_only() cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('str').value.get() cfg.option('str').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_delete():
async def test_mandatory_delete(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_only()
await cfg.property.read_only() cfg.option('str').value.get()
await cfg.option('str').value.get()
try: try:
await cfg.option('str1').value.get() cfg.option('str1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str1').value.set('yes') cfg.option('str1').value.set('yes')
await cfg.property.read_only() cfg.property.read_only()
assert await cfg.option('str1').value.get() == 'yes' assert cfg.option('str1').value.get() == 'yes'
await cfg.property.pop('everything_frozen') cfg.property.remove('everything_frozen')
prop = [] prop = []
try: try:
await cfg.option('str1').value.reset() cfg.option('str1').value.reset()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
await cfg.option('str').value.reset() cfg.option('str').value.reset()
assert await cfg.option('str1').value.get() == 'yes' assert cfg.option('str1').value.get() == 'yes'
assert not await list_sessions() # assert not list_sessions()
#valeur vide : None, '', u'', ... #valeur vide : None, '', u'', ...
@pytest.mark.asyncio def test_mandatory_none():
async def test_mandatory_none(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str1').value.set(None)
await cfg.option('str1').value.set(None) assert cfg.option('str1').owner.get() == 'user'
assert await cfg.option('str1').owner.get() == 'user' cfg.property.read_only()
await cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('str1').value.get() cfg.option('str1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_empty():
async def test_mandatory_empty(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str1').value.set('')
await cfg.option('str1').value.set('') assert cfg.option('str1').owner.get() == 'user'
assert await cfg.option('str1').owner.get() == 'user' cfg.property.read_only()
await cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('str1').value.get() cfg.option('str1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_multi_none():
async def test_mandatory_multi_none(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str3').value.set([None])
await cfg.option('str3').value.set([None]) assert cfg.option('str3').owner.get() == 'user'
assert await cfg.option('str3').owner.get() == 'user' cfg.property.read_only()
await cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('str3').value.get() cfg.option('str3').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str3').value.set(['yes', None]) cfg.option('str3').value.set(['yes', None])
assert await cfg.option('str3').owner.get() == 'user' assert cfg.option('str3').owner.get() == 'user'
await cfg.property.read_only() cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('str3').value.get() cfg.option('str3').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_multi_empty():
async def test_mandatory_multi_empty(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str3').value.set([])
await cfg.option('str3').value.set([]) assert cfg.option('str3').owner.get() == 'user'
assert await cfg.option('str3').owner.get() == 'user' cfg.property.read_only()
await cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('str3').value.get() cfg.option('str3').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
# #
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str3').value.set(['']) cfg.option('str3').value.set([''])
assert await cfg.option('str3').owner.get() == 'user' assert cfg.option('str3').owner.get() == 'user'
await cfg.property.read_only() cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('str3').value.get() cfg.option('str3').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
# #
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str3').value.set(['yes', '']) cfg.option('str3').value.set(['yes', ''])
assert await cfg.option('str3').owner.get() == 'user' assert cfg.option('str3').owner.get() == 'user'
await cfg.property.read_only() cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('str3').value.get() cfg.option('str3').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_multi_append():
async def test_mandatory_multi_append(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str3').value.set(['yes'])
await cfg.option('str3').value.set(['yes']) cfg.property.read_write()
await cfg.property.read_write() ret = cfg.option('str3').value.get()
ret = await cfg.option('str3').value.get()
ret.append(None) ret.append(None)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_disabled():
async def test_mandatory_disabled(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str1').value.get()
await cfg.option('str1').value.get() cfg.option('str1').property.add('disabled')
await cfg.option('str1').property.add('disabled') cfg.property.read_only()
await cfg.property.read_only()
pop = [] pop = []
try: try:
await cfg.option('str1').value.get() cfg.option('str1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
search_prop = {'disabled'} search_prop = {'disabled'}
assert set(prop) == search_prop assert set(prop) == search_prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_unicode():
async def test_mandatory_unicode(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('unicode2').value.get()
await cfg.option('unicode2').value.get() cfg.property.read_only()
await cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('unicode2').value.get() cfg.option('unicode2').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('unicode2').value.set(u'') cfg.option('unicode2').value.set(u'')
await cfg.property.read_only() cfg.property.read_only()
prop = [] prop = []
try: try:
await cfg.option('unicode2').value.get() cfg.option('unicode2').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_warnings_ro():
async def test_mandatory_warnings_ro(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str').value.set('')
await cfg.option('str').value.set('') cfg.property.read_only()
await cfg.property.read_only()
proc = [] proc = []
try: try:
await cfg.option('str').value.get() cfg.option('str').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
assert 'mandatory' in prop assert 'mandatory' in prop
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'unicode2', 'str3'] assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2', 'str3']
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str').value.set('a') cfg.option('str').value.set('a')
await cfg.property.read_only() cfg.property.read_only()
assert list(await cfg.value.mandatory()) == ['str1', 'unicode2', 'str3'] assert list(cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_warnings_rw():
async def test_mandatory_warnings_rw(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str').value.set('')
await cfg.option('str').value.set('') cfg.property.read_write()
await cfg.property.read_write() cfg.option('str').value.get()
await cfg.option('str').value.get() assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2', 'str3']
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'unicode2', 'str3'] cfg.option('str').value.set('a')
await cfg.option('str').value.set('a') assert list(cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
assert list(await cfg.value.mandatory()) == ['str1', 'unicode2', 'str3'] # assert not list_sessions()
assert not await list_sessions()
@pytest.mark.asyncio def test_mandatory_warnings_disabled():
async def test_mandatory_warnings_disabled(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str').value.set('')
await cfg.option('str').value.set('') cfg.property.read_write()
await cfg.property.read_write() cfg.option('str').value.get()
await cfg.option('str').value.get() assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
assert set(await cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'} cfg.option('str').property.add('disabled')
await cfg.option('str').property.add('disabled') assert set(cfg.value.mandatory()) == {'str1', 'unicode2', 'str3'}
assert set(await cfg.value.mandatory()) == {'str1', 'unicode2', 'str3'} # assert not list_sessions()
assert not await list_sessions()
@pytest.mark.asyncio def test_mandatory_warnings_hidden():
async def test_mandatory_warnings_hidden(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str').value.set('')
await cfg.option('str').value.set('') cfg.property.read_write()
await cfg.property.read_write() cfg.permissive.add('hidden')
await cfg.permissive.add('hidden') cfg.option('str').value.get()
await cfg.option('str').value.get() assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
assert set(await cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'} cfg.option('str').property.add('hidden')
await cfg.option('str').property.add('hidden') assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
assert set(await cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'} # assert not list_sessions()
assert not await list_sessions()
@pytest.mark.asyncio def test_mandatory_warnings_frozen():
async def test_mandatory_warnings_frozen(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str').value.set('')
await cfg.option('str').value.set('') cfg.property.read_write()
await cfg.property.read_write() cfg.option('str').value.get()
await cfg.option('str').value.get() assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
assert set(await cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'} cfg.option('str').property.add('frozen')
await cfg.option('str').property.add('frozen') cfg.property.read_only()
await cfg.property.read_only() assert set(cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'}
assert set(await cfg.value.mandatory()) == {'str', 'str1', 'unicode2', 'str3'} # assert not list_sessions()
assert not await list_sessions()
@pytest.mark.asyncio def test_mandatory_leader():
async def test_mandatory_leader():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
properties=('mandatory', )) properties=('mandatory', ))
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True) multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1]) od1 = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_only() cfg.property.read_only()
with pytest.raises(PropertiesOptionError): 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): with pytest.raises(PropertiesOptionError):
await cfg.value.dict() cfg.value.dict()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_leader_sub():
async def test_mandatory_warnings_leader():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
properties=('mandatory', )) properties=('mandatory', ))
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True) multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1]) od1 = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg: od2 = OptionDescription('o', '', [od1])
assert list(await cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0'] cfg = Config(od2)
assert not await list_sessions() 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 def test_mandatory_warnings_leader():
async def test_mandatory_leader_empty(): 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) 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", netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True) multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1]) od1 = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [] assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
# #
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([undefined]) 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 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 cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
await cfg.property.read_only() cfg.property.read_only()
with pytest.raises(PropertiesOptionError): 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): 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() cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset() cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [] assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
# #
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['']) cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([''])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [''] assert 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 cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
await cfg.property.read_only() cfg.property.read_only()
with pytest.raises(PropertiesOptionError): 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): 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() cfg.property.read_write()
# #
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip']) cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
await cfg.property.read_only() cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip'] assert 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 assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
# #
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip2']) cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip2'])
await cfg.property.read_only() cfg.property.read_only()
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset() cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset() cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_warnings_leader_empty():
async def test_mandatory_warnings_leader_empty():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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", netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True) multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1]) od1 = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([undefined]) 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 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 cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert list(await cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0'] assert list(cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset() cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
# #
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['']) cfg.option('ip_admin_eth0.ip_admin_eth0').value.set([''])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [''] assert 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 cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert list(await cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0'] assert list(cfg.value.mandatory()) == ['ip_admin_eth0.ip_admin_eth0']
# #
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip']) cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
assert list(await cfg.value.mandatory()) == [] assert list(cfg.value.mandatory()) == []
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_follower():
async def test_mandatory_follower():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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", netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True, properties=('mandatory', )) multi=True, properties=('mandatory', ))
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1]) od1 = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_only() cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [] assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [],
'ip_admin_eth0.netmask_admin_eth0': []} 'ip_admin_eth0.netmask_admin_eth0': []}
# #
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip']) cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
await cfg.property.read_only() cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip'] assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
with pytest.raises(PropertiesOptionError): 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() cfg.property.read_write()
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('') cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('')
await cfg.property.read_only() cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip'] assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip']
with pytest.raises(PropertiesOptionError): 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() cfg.property.read_write()
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('ip') cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('ip')
await cfg.property.read_only() cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['ip'] assert 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 cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == 'ip'
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['ip'], assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['ip'],
'ip_admin_eth0.netmask_admin_eth0': ['ip']} 'ip_admin_eth0.netmask_admin_eth0': ['ip']}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_warnings_follower():
async def test_mandatory_warnings_follower():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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", netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau",
multi=True, properties=('mandatory', )) multi=True, properties=('mandatory', ))
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
descr = OptionDescription('o', '', [interface1]) od1 = OptionDescription('o', '', [interface1])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_only() cfg.property.read_only()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [] assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
# #
await cfg.property.read_write() cfg.property.read_write()
assert list(await cfg.value.mandatory()) == [] assert list(cfg.value.mandatory()) == []
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip']) cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['ip'])
assert list(await cfg.value.mandatory()) == ['ip_admin_eth0.netmask_admin_eth0'] assert list(cfg.value.mandatory()) == ['ip_admin_eth0.netmask_admin_eth0']
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_warnings_symlink():
async def test_mandatory_warnings_symlink(): od1 = make_description_sym()
descr = make_description_sym() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.option('str').value.set('')
await cfg.option('str').value.set('') cfg.property.read_write()
await cfg.property.read_write() cfg.option('str').value.get()
await cfg.option('str').value.get() assert list(cfg.value.mandatory()) == ['str', 'str1', 'str3']
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'str3'] cfg.option('str').property.add('frozen')
await cfg.option('str').property.add('frozen') cfg.property.read_only()
await cfg.property.read_only() assert list(cfg.value.mandatory()) == ['str', 'str1', 'str3']
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'str3'] # assert not list_sessions()
assert not await list_sessions()
#@pytest.mark.asyncio def test_mandatory_warnings_validate_empty():
#async def test_mandatory_warnings_validate(): od1 = make_description2()
# descr = make_description3() cfg = Config(od1)
# cfg = await Config(descr) cfg.option('str').value.set('')
# await cfg.option('str').value.set('') cfg.property.read_only()
# raises(ValueError, "list(await cfg.value.mandatory())") assert list(cfg.value.mandatory()) == ['str', 'str1', 'str3']
# await cfg.option('str').value.set('test') # assert not list_sessions()
# raises(ValueError, "list(await cfg.value.mandatory())")
@pytest.mark.asyncio def test_mandatory_warnings_requires():
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():
stroption = StrOption('str', 'Test string option', default="abc", stroption = StrOption('str', 'Test string option', default="abc",
properties=('mandatory', )) properties=('mandatory', ))
stroption1 = StrOption('str1', 'Test string option', stroption1 = StrOption('str1', 'Test string option',
@ -615,22 +594,21 @@ async def test_mandatory_warnings_requires():
'expected': ParamValue('yes'), 'expected': ParamValue('yes'),
'no_condition_is_invalid': ParamValue(True)})) 'no_condition_is_invalid': ParamValue(True)}))
stroption3 = StrOption('str3', 'Test string option', multi=True, properties=(mandatory_property,)) stroption3 = StrOption('str3', 'Test string option', multi=True, properties=(mandatory_property,))
descr = OptionDescription('tiram', '', [stroption, stroption1, stroption2, stroption3]) od1 = OptionDescription('tiram', '', [stroption, stroption1, stroption2, stroption3])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.option('str').value.set('') cfg.option('str').value.set('')
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str').value.get() cfg.option('str').value.get()
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'unicode2'] assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2']
await cfg.property.read_only() cfg.property.read_only()
assert list(await cfg.value.mandatory()) == ['str', 'str1', 'unicode2'] assert list(cfg.value.mandatory()) == ['str', 'str1', 'unicode2']
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('str').value.set('yes') cfg.option('str').value.set('yes')
assert list(await cfg.value.mandatory()) == ['str1', 'unicode2', 'str3'] assert list(cfg.value.mandatory()) == ['str1', 'unicode2', 'str3']
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_warnings_requires_leadership():
async def test_mandatory_warnings_requires_leadership():
stroption = StrOption('str', 'Test string option', default="abc", stroption = StrOption('str', 'Test string option', default="abc",
properties=('mandatory', )) properties=('mandatory', ))
stroption1 = StrOption('str1', 'Test string option', multi=True) stroption1 = StrOption('str1', 'Test string option', multi=True)
@ -642,18 +620,17 @@ async def test_mandatory_warnings_requires_leadership():
'default': ParamValue('mandatory')})) 'default': ParamValue('mandatory')}))
stroption2 = StrOption('str2', 'Test string option', multi=True, properties=(mandatory_property,)) stroption2 = StrOption('str2', 'Test string option', multi=True, properties=(mandatory_property,))
leadership = Leadership('leader', 'leadership', [stroption1, stroption2]) leadership = Leadership('leader', 'leadership', [stroption1, stroption2])
descr = OptionDescription('tiram', '', [stroption, leadership]) od1 = OptionDescription('tiram', '', [stroption, leadership])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.option('str').value.set('') cfg.option('str').value.set('')
await cfg.option('leader.str1').value.set(['str']) cfg.option('leader.str1').value.set(['str'])
assert list(await cfg.value.mandatory()) == ['str'] assert list(cfg.value.mandatory()) == ['str']
await cfg.option('str').value.set('yes') cfg.option('str').value.set('yes')
assert list(await cfg.value.mandatory()) == ['leader.str2'] assert list(cfg.value.mandatory()) == ['leader.str2']
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_warnings_requires_leadership_follower():
async def test_mandatory_warnings_requires_leadership_follower():
stroption = StrOption('str', 'Test string option', multi=True) stroption = StrOption('str', 'Test string option', multi=True)
stroption1 = StrOption('str1', 'Test string option', multi=True) stroption1 = StrOption('str1', 'Test string option', multi=True)
mandatory_property = Calculation(calc_value, mandatory_property = Calculation(calc_value,
@ -664,22 +641,21 @@ async def test_mandatory_warnings_requires_leadership_follower():
'default': ParamValue('mandatory')})) 'default': ParamValue('mandatory')}))
stroption2 = StrOption('str2', 'Test string option', multi=True, properties=(mandatory_property,)) stroption2 = StrOption('str2', 'Test string option', multi=True, properties=(mandatory_property,))
leadership = Leadership('leader', 'leadership', [stroption, stroption1, stroption2]) leadership = Leadership('leader', 'leadership', [stroption, stroption1, stroption2])
descr = OptionDescription('tiram', '', [leadership]) od1 = OptionDescription('tiram', '', [leadership])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.option('leader.str').value.set(['str']) cfg.option('leader.str').value.set(['str'])
assert list(await cfg.value.mandatory()) == [] assert list(cfg.value.mandatory()) == []
await cfg.option('leader.str1', 0).value.set('yes') cfg.option('leader.str1', 0).value.set('yes')
assert list(await cfg.value.mandatory()) == ['leader.str2'] assert list(cfg.value.mandatory()) == ['leader.str2']
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_mandatory_od_disabled():
async def test_mandatory_od_disabled():
descr = make_description() descr = make_description()
descr = OptionDescription('od', '', [descr]) od1 = OptionDescription('od', '', [descr])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_only() cfg.property.read_only()
assert list(await cfg.value.mandatory()) == ['tiram.str1', 'tiram.unicode2', 'tiram.str3'] assert list(cfg.value.mandatory()) == ['tiram.str1', 'tiram.unicode2', 'tiram.str3']
await cfg.option('tiram').property.add('disabled') cfg.option('tiram').property.add('disabled')
assert list(await cfg.value.mandatory()) == [] assert list(cfg.value.mandatory()) == []
assert not await list_sessions() # 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 from tiramisu.error import ConfigError
import pytest import pytest
from .config import delete_sessions, event_loop
async def make_metaconfig(): def make_metaconfig():
i1 = IntOption('i1', '') i1 = IntOption('i1', '')
i2 = IntOption('i2', '', default=1) i2 = IntOption('i2', '', default=1)
i3 = IntOption('i3', '') i3 = IntOption('i3', '')
@ -13,85 +12,79 @@ async def make_metaconfig():
i6 = IntOption('i6', '', properties=('disabled',)) i6 = IntOption('i6', '', properties=('disabled',))
od1 = OptionDescription('od1', '', [i1, i2, i3, i4, i5, i6]) od1 = OptionDescription('od1', '', [i1, i2, i3, i4, i5, i6])
od2 = OptionDescription('od2', '', [od1]) 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 def test_multi_parents_path():
async def test_multi_parents_path():
""" """
metacfg1 (1) --- metacfg1 (1) ---
| -- cfg1 | -- cfg1
metacfg2 (2) --- metacfg2 (2) ---
""" """
metacfg1 = await make_metaconfig() metacfg1 = make_metaconfig()
cfg1 = await metacfg1.config.new(type='config', session_id="cfg1") cfg1 = metacfg1.config.new(type='config', name="cfg1")
metacfg2 = await MetaConfig([cfg1], session_id='metacfg2', delete_old_session=True) metacfg2 = MetaConfig([cfg1], name='metacfg2')
# #
assert await metacfg1.config.path() == 'metacfg1' assert metacfg1.config.path() == 'metacfg1'
assert await metacfg2.config.path() == 'metacfg2' assert metacfg2.config.path() == 'metacfg2'
assert await cfg1.config.path() == 'metacfg2.metacfg1.cfg1' assert cfg1.config.path() == 'metacfg2.metacfg1.cfg1'
await delete_sessions([metacfg1, metacfg2])
@pytest.mark.asyncio def test_multi_parents_path_same():
async def test_multi_parents_path_same():
""" """
--- metacfg2 (1) --- --- metacfg2 (1) ---
metacfg1 --| | -- cfg1 metacfg1 --| | -- cfg1
--- metacfg3 (2) --- --- metacfg3 (2) ---
""" """
metacfg1 = await make_metaconfig() metacfg1 = make_metaconfig()
metacfg2 = await metacfg1.config.new(type='metaconfig', session_id="metacfg2") metacfg2 = metacfg1.config.new(type='metaconfig', name="metacfg2")
metacfg3 = await metacfg1.config.new(type='metaconfig', session_id="metacfg3") metacfg3 = metacfg1.config.new(type='metaconfig', name="metacfg3")
cfg1 = await metacfg2.config.new(type='config', session_id="cfg1") cfg1 = metacfg2.config.new(type='config', name="cfg1")
await metacfg3.config.add(cfg1) metacfg3.config.add(cfg1)
# #
assert await metacfg2.config.path() == 'metacfg1.metacfg2' assert metacfg2.config.path() == 'metacfg1.metacfg2'
assert await metacfg3.config.path() == 'metacfg1.metacfg3' assert metacfg3.config.path() == 'metacfg1.metacfg3'
assert await cfg1.config.path() == 'metacfg1.metacfg3.metacfg1.metacfg2.cfg1' assert cfg1.config.path() == 'metacfg1.metacfg3.metacfg1.metacfg2.cfg1'
await metacfg1.option('od1.i1').value.set(1) metacfg1.option('od1.i1').value.set(1)
await metacfg3.option('od1.i1').value.set(2) metacfg3.option('od1.i1').value.set(2)
assert await cfg1.option('od1.i1').value.get() == 1 assert cfg1.option('od1.i1').value.get() == 1
orideep = await cfg1.config.deepcopy(metaconfig_prefix="test_", session_id='test_cfg1') orideep = cfg1.config.deepcopy(metaconfig_prefix="test_", name='test_cfg1')
deep = orideep deep = orideep
while True: while True:
try: try:
children = list(await deep.config.list()) children = list(deep.config.list())
except: except:
break break
assert len(children) < 2 assert len(children) < 2
deep = children[0] deep = children[0]
assert await deep.config.path() == 'test_metacfg3.test_metacfg1.test_metacfg2.test_cfg1' assert deep.config.path() == 'test_metacfg3.test_metacfg1.test_metacfg2.test_cfg1'
assert await cfg1.option('od1.i1').value.get() == 1 assert cfg1.option('od1.i1').value.get() == 1
await delete_sessions([metacfg1, orideep])
@pytest.mark.asyncio def test_multi_parents_value():
async def test_multi_parents_value(): metacfg1 = make_metaconfig()
metacfg1 = await make_metaconfig() cfg1 = metacfg1.config.new(type='config', name="cfg1")
cfg1 = await metacfg1.config.new(type='config', session_id="cfg1") metacfg2 = MetaConfig([cfg1], name='metacfg2')
metacfg2 = await MetaConfig([cfg1], session_id='metacfg2', delete_old_session=True)
# #
assert await cfg1.option('od1.i1').value.get() == None assert cfg1.option('od1.i1').value.get() == None
assert await cfg1.option('od1.i2').value.get() == 1 assert cfg1.option('od1.i2').value.get() == 1
assert await cfg1.option('od1.i3').value.get() == None assert cfg1.option('od1.i3').value.get() == None
# #
assert await metacfg1.option('od1.i1').value.get() == None assert metacfg1.option('od1.i1').value.get() == None
assert await metacfg1.option('od1.i2').value.get() == 1 assert metacfg1.option('od1.i2').value.get() == 1
assert await metacfg1.option('od1.i3').value.get() == None assert metacfg1.option('od1.i3').value.get() == None
# #
assert await metacfg2.option('od1.i1').value.get() == None assert metacfg2.option('od1.i1').value.get() == None
assert await metacfg2.option('od1.i2').value.get() == 1 assert metacfg2.option('od1.i2').value.get() == 1
assert await metacfg2.option('od1.i3').value.get() == None assert metacfg2.option('od1.i3').value.get() == None
# #
await metacfg1.option('od1.i3').value.set(3) metacfg1.option('od1.i3').value.set(3)
assert await metacfg1.option('od1.i3').value.get() == 3 assert metacfg1.option('od1.i3').value.get() == 3
assert await cfg1.option('od1.i3').value.get() == 3 assert cfg1.option('od1.i3').value.get() == 3
assert await metacfg2.option('od1.i2').value.get() == 1 assert metacfg2.option('od1.i2').value.get() == 1
# #
await metacfg2.option('od1.i2').value.set(4) metacfg2.option('od1.i2').value.set(4)
assert await metacfg2.option('od1.i2').value.get() == 4 assert metacfg2.option('od1.i2').value.get() == 4
assert await metacfg1.option('od1.i2').value.get() == 1 assert metacfg1.option('od1.i2').value.get() == 1
assert await cfg1.option('od1.i2').value.get() == 4 assert cfg1.option('od1.i2').value.get() == 4
await delete_sessions([metacfg1, metacfg2])

239
tests/test_option.py
View file

@ -6,11 +6,11 @@ do_autopath()
import pytest import pytest
import warnings import warnings
from tiramisu.error import ValueWarning, APIError
from tiramisu.error import APIError, ConfigError 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 tiramisu.i18n import _
from .config import event_loop
try: try:
groups.family groups.family
@ -22,8 +22,7 @@ def a_func():
return None return None
@pytest.mark.asyncio def test_option_valid_name():
async def test_option_valid_name():
IntOption('test', '') IntOption('test', '')
with pytest.raises(ValueError): with pytest.raises(ValueError):
IntOption(1, "") IntOption(1, "")
@ -31,22 +30,9 @@ async def test_option_valid_name():
with pytest.raises(ValueError): with pytest.raises(ValueError):
SymLinkOption(1, i) SymLinkOption(1, i)
i = SymLinkOption("test1", 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 def test_option_get_information():
async def test_option_get_information():
description = "it's ok" description = "it's ok"
string = 'some informations' string = 'some informations'
i = IntOption('test', description) i = IntOption('test', description)
@ -60,14 +46,12 @@ async def test_option_get_information():
assert i.impl_get_information('doc') == description assert i.impl_get_information('doc') == description
@pytest.mark.asyncio def test_option_get_information_config():
async def test_option_get_information_config():
description = "it's ok" description = "it's ok"
string = 'some informations' string = 'some informations'
i = IntOption('test', description) i = IntOption('test', description)
od = OptionDescription('od', '', [i]) od = OptionDescription('od', '', [i])
async with await Config(od) as cfg: cfg = Config(od)
pass
with pytest.raises(ValueError): with pytest.raises(ValueError):
i.impl_get_information('noinfo') i.impl_get_information('noinfo')
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
@ -76,34 +60,46 @@ async def test_option_get_information_config():
i.impl_get_information('noinfo') i.impl_get_information('noinfo')
assert i.impl_get_information('noinfo', 'default') == 'default' assert i.impl_get_information('noinfo', 'default') == 'default'
assert i.impl_get_information('doc') == description assert i.impl_get_information('doc') == description
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_option_unknown():
async def test_option_get_information_default():
description = "it's ok" description = "it's ok"
string = 'some informations' string = 'some informations'
i = IntOption('test', description) i = IntOption('test', description)
i.impl_set_information('noinfo', 'optdefault') i.impl_set_information('noinfo', 'optdefault')
od = OptionDescription('od', '', [i]) od = OptionDescription('od', '', [i])
async with await Config(od) as cfg: cfg = Config(od)
# #
assert await cfg.option('test').information.get('noinfo', 'falsedefault') == 'optdefault' with pytest.raises(APIError):
# cfg.option('test').unknown.get()
await cfg.option('test').information.set('noinfo', 'notdefault') with pytest.raises(APIError):
assert await cfg.option('test').information.get('noinfo', 'falsedefault') == 'notdefault' # only choice
assert not await list_sessions() cfg.option('test').value.list()
@pytest.mark.asyncio def test_option_get_information_default():
async def test_option_get_information_config2(): 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" description = "it's ok"
string = 'some informations' string = 'some informations'
i = IntOption('test', description) i = IntOption('test', description)
i.impl_set_information('info', string) i.impl_set_information('info', string)
od = OptionDescription('od', '', [i]) od = OptionDescription('od', '', [i])
async with await Config(od) as cfg: cfg = Config(od)
pass
with pytest.raises(ValueError): with pytest.raises(ValueError):
i.impl_get_information('noinfo') i.impl_get_information('noinfo')
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
@ -113,11 +109,10 @@ async def test_option_get_information_config2():
i.impl_get_information('noinfo') i.impl_get_information('noinfo')
assert i.impl_get_information('noinfo', 'default') == 'default' assert i.impl_get_information('noinfo', 'default') == 'default'
assert i.impl_get_information('doc') == description assert i.impl_get_information('doc') == description
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_optiondescription_get_information():
async def test_optiondescription_get_information():
description = "it's ok" description = "it's ok"
string = 'some informations' string = 'some informations'
o = OptionDescription('test', description, []) o = OptionDescription('test', description, [])
@ -127,34 +122,31 @@ async def test_optiondescription_get_information():
o.impl_get_information('noinfo') o.impl_get_information('noinfo')
assert o.impl_get_information('noinfo', 'default') == 'default' assert o.impl_get_information('noinfo', 'default') == 'default'
assert o.impl_get_information('doc') == description assert o.impl_get_information('doc') == description
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_option_isoptiondescription():
async def test_option_isoptiondescription():
i = IntOption('test', '') i = IntOption('test', '')
od = OptionDescription('od', '', [i]) od = OptionDescription('od', '', [i])
od = OptionDescription('od', '', [od]) od = OptionDescription('od', '', [od])
async with await Config(od) as cfg: cfg = Config(od)
assert await cfg.option('od').option.isoptiondescription() assert cfg.option('od').option.isoptiondescription()
assert not await cfg.option('od.test').option.isoptiondescription() assert not cfg.option('od.test').option.isoptiondescription()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_option_double():
async def test_option_double():
i = IntOption('test', '') i = IntOption('test', '')
od = OptionDescription('od1', '', [i]) od = OptionDescription('od1', '', [i])
od = OptionDescription('od2', '', [od]) od = OptionDescription('od2', '', [od])
od = OptionDescription('od3', '', [od]) od = OptionDescription('od3', '', [od])
async with await Config(od) as cfg: cfg = Config(od)
assert await cfg.option('od2.od1.test').value.get() is None assert cfg.option('od2.od1.test').value.get() is None
assert await cfg.option('od2').option('od1').option('test').value.get() is None assert cfg.option('od2').option('od1').option('test').value.get() is None
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_option_multi():
async def test_option_multi():
IntOption('test', '', multi=True) IntOption('test', '', multi=True)
IntOption('test', '', multi=True, default_multi=1) IntOption('test', '', multi=True, default_multi=1)
IntOption('test', '', default=[1], 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 #unvalid default_multi
with pytest.raises(ValueError): with pytest.raises(ValueError):
IntOption('test', '', multi=True, default_multi='yes') IntOption('test', '', multi=True, default_multi='yes')
assert not await list_sessions() # assert not list_sessions()
#@pytest.mark.asyncio def test_unknown_option():
#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():
i = IntOption('test', '') i = IntOption('test', '')
od1 = OptionDescription('od', '', [i]) od1 = OptionDescription('od', '', [i])
od2 = OptionDescription('od', '', [od1]) od2 = OptionDescription('od', '', [od1])
async with await Config(od2) as cfg: cfg = Config(od2)
# test is an option, not an optiondescription # test is an option, not an optiondescription
with pytest.raises(TypeError): with pytest.raises(TypeError):
await cfg.option('od.test.unknown').value.get() cfg.option('od.test.unknown').value.get()
# unknown is an unknown option # unknown is an unknown option
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
await cfg.option('unknown').value.get() cfg.option('unknown').value.get()
# unknown is an unknown option # unknown is an unknown option
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
await cfg.option('od.unknown').value.get() cfg.option('od.unknown').value.get()
# unknown is an unknown optiondescription # unknown is an unknown optiondescription
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
await cfg.option('od.unknown.suboption').value.get() cfg.option('od.unknown.suboption').value.get()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_optiondescription_list():
async def test_optiondescription_list():
groups.notfamily1 = groups.GroupType('notfamily1') groups.notfamily1 = groups.GroupType('notfamily1')
i = IntOption('test', '') i = IntOption('test', '')
i2 = IntOption('test', '') i2 = IntOption('test', '')
@ -206,30 +189,29 @@ async def test_optiondescription_list():
od3.impl_set_group_type(groups.notfamily1) od3.impl_set_group_type(groups.notfamily1)
od2 = OptionDescription('od', '', [od1, od3]) od2 = OptionDescription('od', '', [od1, od3])
od4 = OptionDescription('od', '', [od2]) od4 = OptionDescription('od', '', [od2])
async with await Config(od4) as cfg: cfg = Config(od4)
assert len(list(await cfg.option('od').list('option'))) == 0 assert len(list(cfg.option('od').list('option'))) == 0
assert len(list(await cfg.option('od').list('optiondescription'))) == 2 assert len(list(cfg.option('od').list('optiondescription'))) == 2
assert len(list(await cfg.option('od').list('optiondescription', group_type=groups.family))) == 1 assert len(list(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(cfg.option('od').list('optiondescription', group_type=groups.notfamily1))) == 1
assert len(list(await cfg.option('od.od').list('option'))) == 1 assert len(list(cfg.option('od.od').list('option'))) == 1
assert len(list(await cfg.option('od.od2').list('option'))) == 1 assert len(list(cfg.option('od.od2').list('option'))) == 1
try: try:
list(await cfg.option('od').list('unknown')) list(cfg.option('od').list('unknown'))
except AssertionError: except AssertionError:
pass pass
else: else:
raise Exception('must raise') raise Exception('must raise')
try: try:
list(await cfg.option('od').list('option', group_type='toto')) list(cfg.option('od').list('option', group_type='toto'))
except AssertionError: except AssertionError:
pass pass
else: else:
raise Exception('must raise') raise Exception('must raise')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_optiondescription_group():
async def test_optiondescription_group():
groups.notfamily = groups.GroupType('notfamily') groups.notfamily = groups.GroupType('notfamily')
i = IntOption('test', '') i = IntOption('test', '')
i2 = IntOption('test', '') i2 = IntOption('test', '')
@ -238,28 +220,27 @@ async def test_optiondescription_group():
od3 = OptionDescription('od2', '', [i2]) od3 = OptionDescription('od2', '', [i2])
od3.impl_set_group_type(groups.notfamily) od3.impl_set_group_type(groups.notfamily)
od2 = OptionDescription('od', '', [od1, od3]) od2 = OptionDescription('od', '', [od1, od3])
async with await Config(od2) as cfg: cfg = Config(od2)
assert len(list(await cfg.option.list('option'))) == 0 assert len(list(cfg.option.list('option'))) == 0
assert len(list(await cfg.option.list('optiondescription'))) == 2 assert len(list(cfg.option.list('optiondescription'))) == 2
assert len(list(await cfg.option.list('optiondescription', group_type=groups.family))) == 1 assert len(list(cfg.option.list('optiondescription', group_type=groups.family))) == 1
assert len(list(await cfg.option.list('optiondescription', group_type=groups.notfamily))) == 1 assert len(list(cfg.option.list('optiondescription', group_type=groups.notfamily))) == 1
try: try:
list(await cfg.option.list('unknown')) list(cfg.option.list('unknown'))
except AssertionError: except AssertionError:
pass pass
else: else:
raise Exception('must raise') raise Exception('must raise')
try: try:
list(await cfg.option.list('option', group_type='toto')) list(cfg.option.list('option', group_type='toto'))
except AssertionError: except AssertionError:
pass pass
else: else:
raise Exception('must raise') raise Exception('must raise')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_optiondescription_group_redefined():
async def test_optiondescription_group_redefined():
try: try:
groups.notfamily = groups.GroupType('notfamily') groups.notfamily = groups.GroupType('notfamily')
except: except:
@ -269,59 +250,77 @@ async def test_optiondescription_group_redefined():
od1.impl_set_group_type(groups.family) od1.impl_set_group_type(groups.family)
with pytest.raises(ValueError): with pytest.raises(ValueError):
od1.impl_set_group_type(groups.notfamily) od1.impl_set_group_type(groups.notfamily)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_optiondescription_group_leadership():
async def test_optiondescription_group_leadership():
i = IntOption('test', '') i = IntOption('test', '')
od1 = OptionDescription('od', '', [i]) od1 = OptionDescription('od', '', [i])
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
od1.impl_set_group_type(groups.leadership) od1.impl_set_group_type(groups.leadership)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_asign_optiondescription():
async def test_asign_optiondescription():
i = IntOption('test', '') i = IntOption('test', '')
od1 = OptionDescription('od', '', [i]) od1 = OptionDescription('od', '', [i])
od2 = OptionDescription('od', '', [od1]) od2 = OptionDescription('od', '', [od1])
async with await Config(od2) as cfg: cfg = Config(od2)
with pytest.raises(APIError): with pytest.raises(APIError):
await cfg.option('od').value.set('test') cfg.option('od').value.set('test')
with pytest.raises(APIError): with pytest.raises(APIError):
await cfg.option('od').value.reset() cfg.option('od').value.reset()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_intoption():
async def test_intoption():
i1 = IntOption('test1', 'description', min_number=3) i1 = IntOption('test1', 'description', min_number=3)
i2 = IntOption('test2', 'description', max_number=3) i2 = IntOption('test2', 'description', max_number=3)
od = OptionDescription('od', '', [i1, i2]) i3 = IntOption('test3', 'description', min_number=3, max_number=6, warnings_only=True)
async with await Config(od) as cfg: od = OptionDescription('od', '', [i1, i2, i3])
cfg = Config(od)
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('test1').value.set(2) cfg.option('test1').value.set(2)
await cfg.option('test1').value.set(3) cfg.option('test1').value.set(3)
await cfg.option('test1').value.set(4) assert cfg.option('test1').value.valid() is True
await cfg.option('test2').value.set(2) cfg.option('test1').value.set(4)
await cfg.option('test2').value.set(3) cfg.option('test2').value.set(2)
cfg.option('test2').value.set(3)
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('test2').value.set(4) cfg.option('test2').value.set(4)
assert not await list_sessions() 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 def test_get_display_type():
async def test_get_display_type():
i1 = IntOption('test1', 'description', min_number=3) i1 = IntOption('test1', 'description', min_number=3)
assert i1.get_display_type() == _('integer') assert i1.get_display_type() == _('integer')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_option_not_in_config():
async def test_option_not_in_config():
i1 = IntOption('test1', 'description', min_number=3) i1 = IntOption('test1', 'description', min_number=3)
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
i1.impl_getpath() 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.setting import owners
from tiramisu.error import PropertiesOptionError, ConfigError, LeadershipError from tiramisu.error import PropertiesOptionError, ConfigError, LeadershipError
from tiramisu import IntOption, FloatOption, StrOption, ChoiceOption, \ from tiramisu import IntOption, FloatOption, StrOption, ChoiceOption, \
BoolOption, OptionDescription, Leadership, Config, undefined, delete_session BoolOption, OptionDescription, Leadership, Config, undefined
from tiramisu.storage import list_sessions from .config import config_type, get_config
from .config import config_type, get_config, event_loop
owners.addowner("frozenmultifollower") owners.addowner("frozenmultifollower")
@ -40,8 +39,7 @@ def make_description():
#____________________________________________________________ #____________________________________________________________
# default values # default values
@pytest.mark.asyncio def test_default_is_none(config_type):
async def test_default_is_none(config_type):
""" """
Most constructors take a ``default`` argument that specifies the default Most constructors take a ``default`` argument that specifies the default
value of the option. If this argument is not supplied the default value is 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') dummy1 = BoolOption('dummy1', 'doc dummy')
dummy2 = BoolOption('dummy2', 'doc dummy') dummy2 = BoolOption('dummy2', 'doc dummy')
group = OptionDescription('group', '', [dummy1, dummy2]) od1 = OptionDescription('group', '', [dummy1, dummy2])
async with await Config(group) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
# so when the default value is not set, there is actually a default value # so when the default value is not set, there is actually a default value
assert await cfg.option('dummy1').value.get() is None assert cfg.option('dummy1').value.get() is None
assert await cfg.option('dummy2').value.get() is None assert cfg.option('dummy2').value.get() is None
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_set_defaut_value_from_option_object():
async def test_set_defaut_value_from_option_object():
"""Options have an available default setting and can give it back""" """Options have an available default setting and can give it back"""
b = BoolOption("boolean", "", default=False) b = BoolOption("boolean", "", default=False)
assert b.impl_getdefault() is False assert b.impl_getdefault() is False
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_force_default_on_freeze():
async def test_force_default_on_freeze():
"a frozen option wich is forced returns his default" "a frozen option wich is forced returns his default"
dummy1 = BoolOption('dummy1', 'doc dummy', default=False, properties=('force_default_on_freeze',)) dummy1 = BoolOption('dummy1', 'doc dummy', default=False, properties=('force_default_on_freeze',))
dummy2 = BoolOption('dummy2', 'doc dummy', default=True) dummy2 = BoolOption('dummy2', 'doc dummy', default=True)
group = OptionDescription('group', '', [dummy1, dummy2]) od1 = OptionDescription('group', '', [dummy1, dummy2])
async with await Config(group) as cfg_ori: cfg_ori = Config(od1)
await cfg_ori.property.read_write() cfg_ori.property.read_write()
cfg = cfg_ori cfg = cfg_ori
# FIXME cfg = await get_config(cfg_ori, config_type) # FIXME cfg = get_config(cfg_ori, config_type)
owner = await cfg.owner.get() owner = cfg.owner.get()
await cfg.option('dummy1').value.set(True) cfg.option('dummy1').value.set(True)
await cfg.option('dummy2').value.set(False) cfg.option('dummy2').value.set(False)
assert await cfg.option('dummy1').owner.get() == owner assert cfg.option('dummy1').owner.get() == owner
assert await cfg.option('dummy2').owner.get() == owner assert cfg.option('dummy2').owner.get() == owner
# if config_type == 'tiramisu-api': # if config_type == 'tiramisu-api':
# await cfg.send() # cfg.send()
await cfg_ori.option('dummy1').property.add('frozen') cfg_ori.option('dummy1').property.add('frozen')
await cfg_ori.option('dummy2').property.add('frozen') cfg_ori.option('dummy2').property.add('frozen')
# cfg = await get_config(cfg_ori, config_type) # cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy1').value.get() is False assert cfg.option('dummy1').value.get() is False
assert await cfg.option('dummy2').value.get() is False assert cfg.option('dummy2').value.get() is False
assert await cfg.option('dummy1').owner.isdefault() assert cfg.option('dummy1').owner.isdefault()
assert await cfg.option('dummy2').owner.get() == owner assert cfg.option('dummy2').owner.get() == owner
# if config_type == 'tiramisu-api': # if config_type == 'tiramisu-api':
# await cfg.send() # cfg.send()
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg_ori.option('dummy2').owner.set('frozen') cfg_ori.option('dummy2').owner.set('frozen')
# cfg = await get_config(cfg_ori, config_type) # cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('dummy1').value.reset() cfg.option('dummy1').value.reset()
# if config_type == 'tiramisu-api': # if config_type == 'tiramisu-api':
# await cfg.send() # cfg.send()
await cfg_ori.option('dummy1').property.pop('frozen') cfg_ori.option('dummy1').property.remove('frozen')
# cfg = await get_config(cfg_ori, config_type) # cfg = get_config(cfg_ori, config_type)
await cfg.option('dummy1').value.reset() cfg.option('dummy1').value.reset()
# if config_type == 'tiramisu-api': # if config_type == 'tiramisu-api':
# await cfg.send() # cfg.send()
await cfg.option('dummy1').property.add('frozen') cfg.option('dummy1').property.add('frozen')
# cfg = await get_config(cfg_ori, config_type) # cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('dummy2').owner.set('frozen') cfg.option('dummy2').owner.set('frozen')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_force_default_on_freeze_multi():
async def test_force_default_on_freeze_multi():
dummy1 = BoolOption('dummy1', 'doc dummy', default=[False], properties=('force_default_on_freeze',), multi=True) dummy1 = BoolOption('dummy1', 'doc dummy', default=[False], properties=('force_default_on_freeze',), multi=True)
dummy2 = BoolOption('dummy2', 'doc dummy', default=[True], multi=True) dummy2 = BoolOption('dummy2', 'doc dummy', default=[True], multi=True)
group = OptionDescription('group', '', [dummy1, dummy2]) od1 = OptionDescription('group', '', [dummy1, dummy2])
async with await Config(group) as cfg_ori: cfg_ori = Config(od1)
await cfg_ori.property.read_write() cfg_ori.property.read_write()
cfg = cfg_ori cfg = cfg_ori
# FIXME cfg = await get_config(cfg_ori, config_type) # FIXME cfg = get_config(cfg_ori, config_type)
await cfg.option('dummy1').value.set([undefined, True]) cfg.option('dummy1').value.set([undefined, True])
await cfg.option('dummy2').value.set([undefined, False]) cfg.option('dummy2').value.set([undefined, False])
owner = await cfg.owner.get() owner = cfg.owner.get()
assert await cfg.option('dummy1').owner.get() == owner assert cfg.option('dummy1').owner.get() == owner
assert await cfg.option('dummy2').owner.get() == owner assert cfg.option('dummy2').owner.get() == owner
# if config_type == 'tiramisu-api': # if config_type == 'tiramisu-api':
# await cfg.send() # cfg.send()
await cfg_ori.option('dummy1').property.add('frozen') cfg_ori.option('dummy1').property.add('frozen')
await cfg_ori.option('dummy2').property.add('frozen') cfg_ori.option('dummy2').property.add('frozen')
# cfg = await get_config(cfg_ori, config_type) # cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy1').value.get() == [False] assert cfg.option('dummy1').value.get() == [False]
assert await cfg.option('dummy2').value.get() == [True, False] assert cfg.option('dummy2').value.get() == [True, False]
assert await cfg.option('dummy1').owner.isdefault() assert cfg.option('dummy1').owner.isdefault()
assert await cfg.option('dummy2').owner.get() == owner assert cfg.option('dummy2').owner.get() == owner
# if config_type == 'tiramisu-api': # if config_type == 'tiramisu-api':
# await cfg.send() # cfg.send()
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg_ori.option('dummy2').owner.set('owner') cfg_ori.option('dummy2').owner.set('owner')
# cfg = await get_config(cfg_ori, config_type) # cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('dummy2').value.reset() cfg.option('dummy2').value.reset()
# if config_type == 'tiramisu-api': # if config_type == 'tiramisu-api':
# await cfg.send() # cfg.send()
await cfg_ori.option('dummy1').property.pop('frozen') cfg_ori.option('dummy1').property.remove('frozen')
# cfg = await get_config(cfg_ori, config_type) # cfg = get_config(cfg_ori, config_type)
await cfg.option('dummy1').value.reset() cfg.option('dummy1').value.reset()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_force_default_on_freeze_leader():
async def test_force_default_on_freeze_leader():
dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_default_on_freeze',)) dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_default_on_freeze',))
dummy2 = BoolOption('dummy2', 'Test string option', multi=True) dummy2 = BoolOption('dummy2', 'Test string option', multi=True)
descr = Leadership("dummy1", "", [dummy1, dummy2]) descr = Leadership("dummy1", "", [dummy1, dummy2])
descr = OptionDescription("root", "", [descr]) od1 = OptionDescription("root", "", [descr])
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
await Config(descr, session_id='error') Config(od1)
await delete_session('error') # assert not list_sessions()
assert not await list_sessions()
@pytest.mark.asyncio def test_force_metaconfig_on_freeze_leader():
async def test_force_metaconfig_on_freeze_leader():
dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_metaconfig_on_freeze',)) dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_metaconfig_on_freeze',))
dummy2 = BoolOption('dummy2', 'Test string option', multi=True) dummy2 = BoolOption('dummy2', 'Test string option', multi=True)
descr = Leadership("dummy1", "", [dummy1, dummy2]) descr = Leadership("dummy1", "", [dummy1, dummy2])
descr = OptionDescription("root", "", [descr]) od1 = OptionDescription("root", "", [descr])
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
await Config(descr, session_id='error') Config(od1)
await delete_session('error') # assert not list_sessions()
assert not await list_sessions()
@pytest.mark.asyncio def test_force_default_on_freeze_leader_frozen():
async def test_force_default_on_freeze_leader_frozen():
dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_default_on_freeze', 'frozen')) dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_default_on_freeze', 'frozen'))
dummy2 = BoolOption('dummy2', 'Test string option', multi=True) dummy2 = BoolOption('dummy2', 'Test string option', multi=True)
descr = Leadership("dummy1", "", [dummy1, dummy2]) descr = Leadership("dummy1", "", [dummy1, dummy2])
descr = OptionDescription("root", "", [descr]) od1 = OptionDescription("root", "", [descr])
async with await Config(descr) as cfg: cfg = Config(od1)
with pytest.raises(LeadershipError): with pytest.raises(LeadershipError):
await cfg.option('dummy1.dummy1').property.pop('frozen') cfg.option('dummy1.dummy1').property.remove('frozen')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_force_metaconfig_on_freeze_leader_frozen():
async def test_force_metaconfig_on_freeze_leader_frozen():
dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_metaconfig_on_freeze', 'frozen')) dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('force_metaconfig_on_freeze', 'frozen'))
dummy2 = BoolOption('dummy2', 'Test string option', multi=True) dummy2 = BoolOption('dummy2', 'Test string option', multi=True)
descr = Leadership("dummy1", "", [dummy1, dummy2]) descr = Leadership("dummy1", "", [dummy1, dummy2])
descr = OptionDescription("root", "", [descr]) od1 = OptionDescription("root", "", [descr])
async with await Config(descr) as cfg: cfg = Config(od1)
with pytest.raises(LeadershipError): with pytest.raises(LeadershipError):
await cfg.option('dummy1.dummy1').property.pop('frozen') cfg.option('dummy1.dummy1').property.remove('frozen')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_force_default_on_freeze_follower(config_type):
async def test_force_default_on_freeze_follower(config_type):
dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('notunique',)) dummy1 = BoolOption('dummy1', 'Test int option', multi=True, properties=('notunique',))
dummy2 = BoolOption('dummy2', 'Test string option', multi=True, properties=('force_default_on_freeze',)) dummy2 = BoolOption('dummy2', 'Test string option', multi=True, properties=('force_default_on_freeze',))
descr = Leadership("dummy1", "", [dummy1, dummy2]) descr = Leadership("dummy1", "", [dummy1, dummy2])
descr = OptionDescription("root", "", [descr]) od1 = OptionDescription("root", "", [descr])
async with await Config(descr) as cfg_ori: cfg_ori = Config(od1)
await cfg_ori.property.read_write() cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
await cfg.option('dummy1.dummy1').value.set([True]) cfg.option('dummy1.dummy1').value.set([True])
await cfg.option('dummy1.dummy2', 0).value.set(False) cfg.option('dummy1.dummy2', 0).value.set(False)
assert await cfg.option('dummy1.dummy1').value.get() == [True] assert cfg.option('dummy1.dummy1').value.get() == [True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == False assert cfg.option('dummy1.dummy2', 0).value.get() == False
assert await cfg.option('dummy1.dummy1').owner.get() == 'user' assert cfg.option('dummy1.dummy1').owner.get() == 'user'
assert await cfg.option('dummy1.dummy2', 0).owner.get() == 'user' assert cfg.option('dummy1.dummy2', 0).owner.get() == 'user'
# #
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.option('dummy1.dummy2').property.add('frozen') cfg_ori.option('dummy1.dummy2').property.add('frozen')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy1.dummy1').value.get() == [True] assert cfg.option('dummy1.dummy1').value.get() == [True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == None assert cfg.option('dummy1.dummy2', 0).value.get() == None
assert await cfg.option('dummy1.dummy1').owner.get() == 'user' assert cfg.option('dummy1.dummy1').owner.get() == 'user'
assert await cfg.option('dummy1.dummy2', 0).owner.isdefault() assert cfg.option('dummy1.dummy2', 0).owner.isdefault()
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg_ori.option('dummy1.dummy2', 0).owner.set('frozenmultifollower') cfg_ori.option('dummy1.dummy2', 0).owner.set('frozenmultifollower')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
# #
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.option('dummy1.dummy2').property.pop('frozen') cfg_ori.option('dummy1.dummy2').property.remove('frozen')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
await cfg.option('dummy1.dummy1').value.set([True, True]) cfg.option('dummy1.dummy1').value.set([True, True])
await cfg.option('dummy1.dummy2', 1).value.set(False) cfg.option('dummy1.dummy2', 1).value.set(False)
assert await cfg.option('dummy1.dummy1').value.get() == [True, True] assert cfg.option('dummy1.dummy1').value.get() == [True, True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == False assert cfg.option('dummy1.dummy2', 0).value.get() == False
assert await cfg.option('dummy1.dummy2', 1).value.get() == False assert cfg.option('dummy1.dummy2', 1).value.get() == False
# #
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.option('dummy1.dummy2').property.add('frozen') cfg_ori.option('dummy1.dummy2').property.add('frozen')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy1.dummy1').value.get() == [True, True] assert cfg.option('dummy1.dummy1').value.get() == [True, True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == None assert cfg.option('dummy1.dummy2', 0).value.get() == None
assert await cfg.option('dummy1.dummy2', 1).value.get() == None assert cfg.option('dummy1.dummy2', 1).value.get() == None
# #
await cfg.option('dummy1.dummy1').value.pop(1) cfg.option('dummy1.dummy1').value.pop(1)
assert await cfg.option('dummy1.dummy1').value.get() == [True] assert cfg.option('dummy1.dummy1').value.get() == [True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == None assert cfg.option('dummy1.dummy2', 0).value.get() == None
# #
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.option('dummy1.dummy2').property.pop('frozen') cfg_ori.option('dummy1.dummy2').property.remove('frozen')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy1.dummy1').value.get() == [True] assert cfg.option('dummy1.dummy1').value.get() == [True]
assert await cfg.option('dummy1.dummy2', 0).value.get() == False assert cfg.option('dummy1.dummy2', 0).value.get() == False
# #
await cfg.option('dummy1.dummy1').value.set([True, True]) cfg.option('dummy1.dummy1').value.set([True, True])
assert await cfg.option('dummy1.dummy2', 0).value.get() == False assert cfg.option('dummy1.dummy2', 0).value.get() == False
assert await cfg.option('dummy1.dummy2', 1).value.get() == None assert cfg.option('dummy1.dummy2', 1).value.get() == None
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_overrides_changes_option_value(config_type):
async def test_overrides_changes_option_value(config_type):
"with config.override(), the default is changed and the value is changed" "with config.override(), the default is changed and the value is changed"
descr = OptionDescription("test", "", [ od1 = OptionDescription("test", "", [
BoolOption("b", "", default=False)]) BoolOption("b", "", default=False)])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
await cfg.option('b').value.set(True) cfg.option('b').value.set(True)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_choice_with_no_default(config_type):
async def test_choice_with_no_default(config_type): od1 = OptionDescription("test", "", [
descr = OptionDescription("test", "", [
ChoiceOption("backend", "", ("c", "cli"))]) ChoiceOption("backend", "", ("c", "cli"))])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.option('backend').value.get() is None assert cfg.option('backend').value.get() is None
await cfg.option('backend').value.set('c') cfg.option('backend').value.set('c')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_choice_with_default(config_type):
async def test_choice_with_default(config_type): od1 = OptionDescription("test", "", [
descr = OptionDescription("test", "", [
ChoiceOption("backend", "", ("c", "cli"), default="cli")]) ChoiceOption("backend", "", ("c", "cli"), default="cli")])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.option('backend').value.get() == 'cli' assert cfg.option('backend').value.get() == 'cli'
assert not await list_sessions() # 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, \ from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
StrOption, OptionDescription, SymLinkOption, Leadership, Config StrOption, OptionDescription, SymLinkOption, Leadership, Config
from tiramisu.error import ConfigError, ConstError, PropertiesOptionError, APIError from tiramisu.error import ConfigError, ConstError, PropertiesOptionError, APIError
from tiramisu.storage import list_sessions from .config import config_type, get_config
from .config import config_type, get_config, event_loop
owners.addowner("readonly2") owners.addowner("readonly2")
@ -37,217 +36,214 @@ def make_description():
return descr return descr
@pytest.mark.asyncio def test_default_owner(config_type):
async def test_default_owner(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False) gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy]) od1 = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.option('dummy').value.get() is False assert cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default' assert cfg.option('dummy').owner.get() == 'default'
await cfg.option('dummy').value.set(True) cfg.option('dummy').value.set(True)
owner = await cfg.owner.get() owner = cfg.owner.get()
assert await cfg.option('dummy').owner.get() == owner assert cfg.option('dummy').owner.get() == owner
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_owner_unknown_func(config_type):
async def test_hidden_owner(): 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',)) gcdummy = BoolOption('dummy', 'dummy', default=False, properties=('hidden',))
descr = OptionDescription('tiramisu', '', [gcdummy]) od1 = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
#with pytest.raises(PropertiesOptionError): #with pytest.raises(PropertiesOptionError):
# await cfg.forcepermissive.option('dummy').owner.get() # cfg.forcepermissive.option('dummy').owner.get()
#with pytest.raises(PropertiesOptionError): #with pytest.raises(PropertiesOptionError):
# await cfg.option('dummy').owner.isdefault() # cfg.option('dummy').owner.isdefault()
#with pytest.raises(PropertiesOptionError): #with pytest.raises(PropertiesOptionError):
# await cfg.forcepermissive.option('dummy').owner.isdefault() # cfg.forcepermissive.option('dummy').owner.isdefault()
await cfg.permissive.add('hidden') cfg.permissive.add('hidden')
await cfg.forcepermissive.option('dummy').value.get() cfg.forcepermissive.option('dummy').value.get()
await cfg.forcepermissive.option('dummy').owner.isdefault() cfg.forcepermissive.option('dummy').owner.isdefault()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_addowner(config_type):
async def test_addowner(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False) gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy]) od1 = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg_ori: cfg_ori = Config(od1)
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy').value.get() is False assert cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default' assert cfg.option('dummy').owner.get() == 'default'
assert await cfg.option('dummy').owner.isdefault() assert cfg.option('dummy').owner.isdefault()
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.owner.set('gen_config') cfg_ori.owner.set('gen_config')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
await cfg.option('dummy').value.set(True) cfg.option('dummy').value.set(True)
assert await cfg.option('dummy').owner.get() == owners.gen_config assert cfg.option('dummy').owner.get() == owners.gen_config
assert not await cfg.option('dummy').owner.isdefault() assert not cfg.option('dummy').owner.isdefault()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_addowner_multiple_time():
async def test_addowner_multiple_time():
owners.addowner("testowner2") owners.addowner("testowner2")
with pytest.raises(ConstError): with pytest.raises(ConstError):
owners.addowner("testowner2") owners.addowner("testowner2")
@pytest.mark.asyncio def test_delete_owner():
async def test_delete_owner():
owners.addowner('deleted2') owners.addowner('deleted2')
with pytest.raises(ConstError): with pytest.raises(ConstError):
del(owners.deleted2) del(owners.deleted2)
@pytest.mark.asyncio def test_owner_is_not_a_string(config_type):
async def test_owner_is_not_a_string(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False) gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy]) od1 = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.option('dummy').value.get() is False assert cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == owners.default assert cfg.option('dummy').owner.get() == owners.default
assert await cfg.option('dummy').owner.get() == 'default' assert cfg.option('dummy').owner.get() == 'default'
if config_type == 'tiramisu': if config_type == 'tiramisu':
assert isinstance(await cfg.option('dummy').owner.get(), owners.Owner) assert isinstance(cfg.option('dummy').owner.get(), owners.Owner)
await cfg.option('dummy').value.set(True) cfg.option('dummy').value.set(True)
assert await cfg.option('dummy').owner.get() == 'user' assert cfg.option('dummy').owner.get() == 'user'
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_setowner_without_valid_owner(config_type):
async def test_setowner_without_valid_owner(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False) gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy]) od1 = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.option('dummy').value.get() is False assert cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default' assert cfg.option('dummy').owner.get() == 'default'
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_setowner_for_value(config_type):
async def test_setowner_for_value(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False) gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy]) od1 = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg_ori: cfg_ori = Config(od1)
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy').value.get() is False assert cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default' assert cfg.option('dummy').owner.get() == 'default'
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
await cfg_ori.option('dummy').owner.set('new2') cfg_ori.option('dummy').owner.set('new2')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
await cfg.option('dummy').value.set(False) cfg.option('dummy').value.set(False)
assert await cfg.option('dummy').owner.get() == owners.user assert cfg.option('dummy').owner.get() == owners.user
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.option('dummy').owner.set('new2') cfg_ori.option('dummy').owner.set('new2')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy').owner.get() == owners.new2 assert cfg.option('dummy').owner.get() == owners.new2
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_setowner_forbidden(config_type):
async def test_setowner_forbidden(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False) gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy]) od1 = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg_ori: cfg_ori = Config(od1)
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy').value.get() is False assert cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default' assert cfg.option('dummy').owner.get() == 'default'
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg_ori.owner.set('default') cfg_ori.owner.set('default')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
await cfg.option('dummy').value.set(False) cfg.option('dummy').value.set(False)
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg_ori.option('dummy').owner.set('default') cfg_ori.option('dummy').owner.set('default')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_setowner_read_only(config_type):
async def test_setowner_read_only(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False) gcdummy = BoolOption('dummy', 'dummy', default=False)
descr = OptionDescription('tiramisu', '', [gcdummy]) od1 = OptionDescription('tiramisu', '', [gcdummy])
async with await Config(descr) as cfg_ori: cfg_ori = Config(od1)
await cfg_ori.property.read_write() cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy').value.get() is False assert cfg.option('dummy').value.get() is False
assert await cfg.option('dummy').owner.get() == 'default' assert cfg.option('dummy').owner.get() == 'default'
await cfg.option('dummy').value.set(False) cfg.option('dummy').value.set(False)
assert await cfg.option('dummy').owner.get() == owners.user assert cfg.option('dummy').owner.get() == owners.user
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.property.read_only() cfg_ori.property.read_only()
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg_ori.option('dummy').owner.set('readonly2') cfg_ori.option('dummy').owner.set('readonly2')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('dummy').owner.get() == owners.user assert cfg.option('dummy').owner.get() == owners.user
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_setowner_optiondescription(config_type):
async def test_setowner_optiondescription(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False) gcdummy = BoolOption('dummy', 'dummy', default=False)
descr1 = OptionDescription('tiramisu', '', [gcdummy]) descr1 = OptionDescription('tiramisu', '', [gcdummy])
descr = OptionDescription('tiramisu', '', [descr1]) od1 = OptionDescription('tiramisu', '', [descr1])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
with pytest.raises(APIError): with pytest.raises(APIError):
await cfg.option('tiramisu').owner.get() cfg.option('tiramisu').owner.get()
with pytest.raises(APIError): with pytest.raises(APIError):
await cfg.option('tiramisu').owner.set('user') cfg.option('tiramisu').owner.set('user')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_setowner_symlinkoption(config_type):
async def test_setowner_symlinkoption(config_type):
gcdummy = BoolOption('dummy', 'dummy', default=False) gcdummy = BoolOption('dummy', 'dummy', default=False)
s = SymLinkOption('symdummy', gcdummy) s = SymLinkOption('symdummy', gcdummy)
descr1 = OptionDescription('tiramisu', '', [gcdummy, s]) descr1 = OptionDescription('tiramisu', '', [gcdummy, s])
descr = OptionDescription('tiramisu', '', [descr1]) od1 = OptionDescription('tiramisu', '', [descr1])
async with await Config(descr) as cfg_ori: cfg_ori = Config(od1)
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('tiramisu.symdummy').owner.isdefault() assert cfg.option('tiramisu.symdummy').owner.isdefault()
await cfg.option('tiramisu.dummy').value.set(True) cfg.option('tiramisu.dummy').value.set(True)
assert not await cfg.option('tiramisu.symdummy').owner.isdefault() assert not cfg.option('tiramisu.symdummy').owner.isdefault()
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
await cfg_ori.option('tiramisu.symdummy').owner.set('user') cfg_ori.option('tiramisu.symdummy').owner.set('user')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_owner_leadership(config_type):
async def test_owner_leadership(config_type):
b = IntOption('int', 'Test int option', default=[0], multi=True) b = IntOption('int', 'Test int option', default=[0], multi=True)
c = StrOption('str', 'Test string option', multi=True) c = StrOption('str', 'Test string option', multi=True)
descr = Leadership("int", "", [b, c]) descr = Leadership("int", "", [b, c])
od = OptionDescription('od', '', [descr]) od1 = OptionDescription('od', '', [descr])
async with await Config(od) as cfg_ori: cfg_ori = Config(od1)
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
await cfg_ori.option('int.str', 0).owner.set('user') cfg_ori.option('int.str', 0).owner.set('user')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
await cfg.option('int.int').value.set([0, 1]) cfg.option('int.int').value.set([0, 1])
await cfg.option('int.str', 0).value.set('yes') cfg.option('int.str', 0).value.set('yes')
assert not await cfg.option('int.str', 0).owner.isdefault() assert not cfg.option('int.str', 0).owner.isdefault()
assert await cfg.option('int.str', 1).owner.isdefault() assert cfg.option('int.str', 1).owner.isdefault()
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.option('int.str', 0).owner.set('user') cfg_ori.option('int.str', 0).owner.set('user')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('int.str', 0).owner.get() == owners.user assert cfg.option('int.str', 0).owner.get() == owners.user
assert await cfg.option('int.str', 1).owner.isdefault() assert cfg.option('int.str', 1).owner.isdefault()
assert await cfg.option('int.str', 0).value.get() == 'yes' assert cfg.option('int.str', 0).value.get() == 'yes'
assert await cfg.option('int.str', 1).value.get() == None assert cfg.option('int.str', 1).value.get() == None
assert not await list_sessions() # 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, \ PasswordOption, StrOption, DateOption, OptionDescription, Config, \
Calculation, Params, ParamOption, ParamValue, calc_value Calculation, Params, ParamOption, ParamValue, calc_value
from tiramisu.error import PropertiesOptionError from tiramisu.error import PropertiesOptionError
from tiramisu.storage import list_sessions from .config import config_type, get_config
from .config import config_type, get_config, event_loop
def make_description(): def make_description():
@ -49,73 +48,70 @@ def make_description():
# ____________________________________________________________ # ____________________________________________________________
@pytest.mark.asyncio def test_is_hidden(config_type):
async def test_is_hidden(config_type): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write() assert not 'frozen' in cfg.forcepermissive.option('gc.dummy').property.get()
assert not 'frozen' in await cfg.forcepermissive.option('gc.dummy').property.get() cfg = get_config(cfg, config_type)
cfg = await get_config(cfg, config_type)
# setattr # setattr
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('gc.dummy').value.get() == False cfg.option('gc.dummy').value.get() == False
# getattr # getattr
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('gc.dummy').value.get() cfg.option('gc.dummy').value.get()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_group_is_hidden(config_type):
async def test_group_is_hidden(config_type): od1 = make_description()
descr = make_description() cfg_ori = Config(od1)
async with await Config(descr) as cfg_ori: cfg_ori.property.read_write()
await cfg_ori.property.read_write() cfg_ori.option('gc').property.add('hidden')
await cfg_ori.option('gc').property.add('hidden') cfg = get_config(cfg_ori, config_type)
cfg = await get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('gc.dummy').value.get() cfg.option('gc.dummy').value.get()
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
assert 'hidden' in await cfg_ori.forcepermissive.option('gc').property.get() assert 'hidden' in cfg_ori.forcepermissive.option('gc').property.get()
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('gc.float').value.get() cfg.option('gc.float').value.get()
# manually set the subconfigs to "show" # manually set the subconfigs to "show"
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.forcepermissive.option('gc').property.pop('hidden') cfg_ori.forcepermissive.option('gc').property.remove('hidden')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert not 'hidden' in await cfg.option('gc').property.get() assert not 'hidden' in cfg.option('gc').property.get()
assert await cfg.option('gc.float').value.get() == 2.3 assert cfg.option('gc.float').value.get() == 2.3
#dummy est en hide #dummy est en hide
prop = [] prop = []
try: try:
await cfg.option('gc.dummy').value.set(False) cfg.option('gc.dummy').value.set(False)
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
assert 'disabled' in prop assert 'disabled' in prop
else: else:
assert 'hidden' in prop assert 'hidden' in prop
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_group_is_hidden_multi(config_type):
async def test_group_is_hidden_multi(config_type): od1 = make_description()
descr = make_description() cfg_ori = Config(od1)
async with await Config(descr) as cfg_ori: cfg_ori.property.read_write()
await cfg_ori.property.read_write() cfg_ori.option('objspace').property.add('hidden')
await cfg_ori.option('objspace').property.add('hidden') cfg = get_config(cfg_ori, config_type)
cfg = await get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('objspace').value.get() cfg.option('objspace').value.get()
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
assert 'hidden' in await cfg_ori.forcepermissive.option('objspace').property.get() assert 'hidden' in cfg_ori.forcepermissive.option('objspace').property.get()
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
prop = [] prop = []
try: try:
await cfg.option('objspace').value.set(['std']) cfg.option('objspace').value.set(['std'])
except PropertiesOptionError as err: except PropertiesOptionError as err:
prop = err.proptype prop = err.proptype
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
@ -123,76 +119,72 @@ async def test_group_is_hidden_multi(config_type):
else: else:
assert 'hidden' in prop assert 'hidden' in prop
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.forcepermissive.option('objspace').property.pop('hidden') cfg_ori.forcepermissive.option('objspace').property.remove('hidden')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert not 'hidden' in await cfg.option('objspace').property.get() assert not 'hidden' in cfg.option('objspace').property.get()
await cfg.option('objspace').value.set(['std', 'thunk']) cfg.option('objspace').value.set(['std', 'thunk'])
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_global_show(config_type):
async def test_global_show(config_type): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write() cfg.forcepermissive.option('gc.dummy').property.add('hidden')
await cfg.forcepermissive.option('gc.dummy').property.add('hidden') assert 'hidden' in cfg.forcepermissive.option('gc.dummy').property.get()
assert 'hidden' in await cfg.forcepermissive.option('gc.dummy').property.get() cfg = get_config(cfg, config_type)
cfg = await get_config(cfg, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('gc.dummy').value.get() == False cfg.option('gc.dummy').value.get() == False
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_with_many_subgroups(config_type):
async def test_with_many_subgroups(config_type): od1 = make_description()
descr = make_description() cfg_ori = Config(od1)
async with await Config(descr) as cfg_ori:
#booltwo = config.unwrap_from_path('gc.subgroup.booltwo') #booltwo = config.unwrap_from_path('gc.subgroup.booltwo')
#setting = config.cfgimpl_get_settings() #setting = config.cfgimpl_get_settings()
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert not 'hidden' in await cfg.option('gc.subgroup.booltwo').property.get() assert not 'hidden' in cfg.option('gc.subgroup.booltwo').property.get()
assert await cfg.option('gc.subgroup.booltwo').value.get() is False assert cfg.option('gc.subgroup.booltwo').value.get() is False
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.option('gc.subgroup.booltwo').property.add('hidden') cfg_ori.option('gc.subgroup.booltwo').property.add('hidden')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_password_option(config_type):
async def test_password_option(config_type):
o = PasswordOption('o', '') o = PasswordOption('o', '')
d = OptionDescription('d', '', [o]) od1 = OptionDescription('d', '', [o])
async with await Config(d) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) 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): with pytest.raises(ValueError):
await cfg.option('o').value.set(1) cfg.option('o').value.set(1)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_date_option(config_type):
async def test_date_option(config_type):
o = DateOption('o', '') o = DateOption('o', '')
d = OptionDescription('d', '', [o]) od1 = OptionDescription('d', '', [o])
async with await Config(d) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
await cfg.option('o').value.set('2017-02-04') cfg.option('o').value.set('2017-02-04')
await cfg.option('o').value.set('2017-2-4') cfg.option('o').value.set('2017-2-4')
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('o').value.set(1) cfg.option('o').value.set(1)
with pytest.raises(ValueError): 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): 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): 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): 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): 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): with pytest.raises(ValueError):
await cfg.option('o').value.set('2017/2/2') cfg.option('o').value.set('2017/2/2')
assert not await list_sessions() # 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 import pytest
from tiramisu import BoolOption, OptionDescription, ChoiceOption,\ from tiramisu import BoolOption, OptionDescription, ChoiceOption,\
IntOption, FloatOption, StrOption, Config IntOption, FloatOption, StrOption, Config
from tiramisu.storage import list_sessions from .config import config_type, get_config
from .config import config_type, get_config, event_loop
def make_description(): def make_description():
@ -32,34 +31,26 @@ def make_description():
return descr return descr
@pytest.mark.asyncio def test_root_config_answers_ok(config_type):
async def test_root_config_answers_ok(config_type):
"if you hide the root config, the options in this namespace behave normally" "if you hide the root config, the options in this namespace behave normally"
gcdummy = BoolOption('dummy', 'dummy', default=False) gcdummy = BoolOption('dummy', 'dummy', default=False)
boolop = BoolOption('boolop', 'Test boolean option op', default=True) boolop = BoolOption('boolop', 'Test boolean option op', default=True)
descr = OptionDescription('tiramisu', '', [gcdummy, boolop]) od1 = OptionDescription('tiramisu', '', [gcdummy, boolop])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
#settings = await cfg.cfgimpl_get_settings() #settings = cfg.cfgimpl_get_settings()
#settings.append('hidden') #settings.append('hidden')
assert await cfg.option('dummy').value.get() is False assert cfg.option('dummy').value.get() is False
assert await cfg.option('boolop').value.get() is True assert cfg.option('boolop').value.get() is True
assert not await list_sessions() # assert not list_sessions()
#@pytest.mark.asyncio def test_option_has_an_api_name(config_type):
# 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):
b = BoolOption('impl_has_dependency', 'dummy', default=True) b = BoolOption('impl_has_dependency', 'dummy', default=True)
descr = OptionDescription('tiramisu', '', [b]) od1 = OptionDescription('tiramisu', '', [b])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.option('impl_has_dependency').value.get() is True assert cfg.option('impl_has_dependency').value.get() is True
assert b.impl_has_dependency() is False 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 import pytest
from tiramisu import IntOption, StrOption, OptionDescription, Config from tiramisu import IntOption, StrOption, OptionDescription, Config
from tiramisu.error import PropertiesOptionError, ConfigError from tiramisu.error import PropertiesOptionError, ConfigError, APIError
from tiramisu.storage import list_sessions, delete_session from .config import config_type, get_config
from .config import config_type, get_config, event_loop
def make_description(): def make_description():
@ -16,428 +15,414 @@ def make_description():
return OptionDescription('od1', '', [u1, u2]) return OptionDescription('od1', '', [u1, u2])
@pytest.mark.asyncio def test_forcepermissive_and_unrestraint(config_type):
async def test_permissive(config_type): od1 = make_description()
descr = make_description() cfg_ori = Config(od1)
async with await Config(descr) as cfg_ori: cfg_ori.property.read_write()
await cfg_ori.property.read_write() cfg_ori.property.read_write()
await cfg_ori.property.read_write() cfg = get_config(cfg_ori, config_type)
cfg = await 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() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.unrestraint.permissive.add('disabled') cfg_ori.unrestraint.permissive.add('disabled')
await cfg_ori.unrestraint.permissive.pop('hidden') cfg_ori.unrestraint.permissive.remove('hidden')
assert await cfg_ori.unrestraint.permissive.get() == frozenset(['disabled']) assert cfg_ori.unrestraint.permissive.get() == frozenset(['disabled'])
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.property.add('permissive') cfg_ori.property.add('permissive')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
await cfg.option('u1').value.get() cfg.option('u1').value.get()
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.property.pop('permissive') cfg_ori.property.remove('permissive')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_permissive_add(config_type):
async def test_permissive_add(config_type): od1 = make_description()
descr = make_description() cfg_ori = Config(od1)
async with await Config(descr) as cfg_ori: cfg_ori.property.read_write()
await cfg_ori.property.read_write() cfg_ori.property.read_write()
await cfg_ori.property.read_write() cfg = get_config(cfg_ori, config_type)
cfg = await get_config(cfg_ori, config_type)
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.unrestraint.permissive.add('disabled') cfg_ori.unrestraint.permissive.add('disabled')
assert await cfg_ori.unrestraint.permissive.get() == frozenset(['hidden', 'disabled']) assert cfg_ori.unrestraint.permissive.get() == frozenset(['hidden', 'disabled'])
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.property.add('permissive') cfg_ori.property.add('permissive')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
await cfg.option('u1').value.get() cfg.option('u1').value.get()
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.property.pop('permissive') cfg_ori.property.remove('permissive')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_permissive_pop():
async def test_permissive_pop(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write() cfg.property.read_write()
await cfg.property.read_write()
props = frozenset() props = frozenset()
try: try:
await cfg.forcepermissive.option('u1').value.get() cfg.forcepermissive.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
await cfg.unrestraint.permissive.add('disabled') cfg.unrestraint.permissive.add('disabled')
assert await cfg.unrestraint.permissive.get() == frozenset(['hidden', 'disabled']) assert cfg.unrestraint.permissive.get() == frozenset(['hidden', 'disabled'])
await cfg.forcepermissive.option('u1').value.get() cfg.forcepermissive.option('u1').value.get()
await cfg.unrestraint.permissive.pop('disabled') cfg.unrestraint.permissive.remove('disabled')
props = frozenset() props = frozenset()
try: try:
await cfg.forcepermissive.option('u1').value.get() cfg.forcepermissive.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_permissive_reset():
async def test_permissive_reset(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write() assert cfg.unrestraint.permissive.get() == frozenset(['hidden'])
assert await cfg.unrestraint.permissive.get() == frozenset(['hidden'])
# #
await cfg.unrestraint.permissive.add('disabled') cfg.unrestraint.permissive.add('disabled')
await cfg.unrestraint.permissive.pop('hidden') cfg.unrestraint.permissive.remove('hidden')
assert await cfg.unrestraint.permissive.get() == frozenset(['disabled']) assert cfg.unrestraint.permissive.get() == frozenset(['disabled'])
# #
await cfg.unrestraint.permissive.reset() cfg.unrestraint.permissive.reset()
assert await cfg.unrestraint.permissive.get() == frozenset() assert cfg.unrestraint.permissive.get() == frozenset()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_permissive_mandatory():
async def test_permissive_mandatory(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_only()
await cfg.property.read_only()
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert frozenset(props) == frozenset(['disabled']) assert frozenset(props) == frozenset(['disabled'])
await cfg.unrestraint.permissive.add('mandatory') cfg.unrestraint.permissive.add('mandatory')
await cfg.unrestraint.permissive.add('disabled') cfg.unrestraint.permissive.add('disabled')
assert await cfg.unrestraint.permissive.get() == frozenset(['mandatory', 'disabled']) assert cfg.unrestraint.permissive.get() == frozenset(['mandatory', 'disabled'])
await cfg.property.add('permissive') cfg.property.add('permissive')
await cfg.option('u1').value.get() cfg.option('u1').value.get()
await cfg.property.pop('permissive') cfg.property.remove('permissive')
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert frozenset(props) == frozenset(['disabled']) assert frozenset(props) == frozenset(['disabled'])
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_permissive_frozen():
async def test_permissive_frozen(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write() cfg.unrestraint.permissive.remove('hidden')
await cfg.unrestraint.permissive.pop('hidden') cfg.unrestraint.permissive.add('frozen')
await cfg.unrestraint.permissive.add('frozen') cfg.unrestraint.permissive.add('disabled')
await cfg.unrestraint.permissive.add('disabled') assert cfg.unrestraint.permissive.get() == frozenset(['frozen', 'disabled'])
assert await cfg.unrestraint.permissive.get() == frozenset(['frozen', 'disabled']) assert cfg.permissive.get() == frozenset(['frozen', 'disabled'])
assert await cfg.permissive.get() == frozenset(['frozen', 'disabled'])
try: try:
await cfg.option('u1').value.set(1) cfg.option('u1').value.set(1)
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert frozenset(props) == frozenset(['disabled']) assert frozenset(props) == frozenset(['disabled'])
await cfg.property.add('permissive') cfg.property.add('permissive')
await cfg.option('u1').value.set(1) cfg.option('u1').value.set(1)
assert await cfg.option('u1').value.get() == 1 assert cfg.option('u1').value.get() == 1
await cfg.property.pop('permissive') cfg.property.remove('permissive')
try: try:
await cfg.option('u1').value.set(1) cfg.option('u1').value.set(1)
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert frozenset(props) == frozenset(['disabled']) assert frozenset(props) == frozenset(['disabled'])
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_forbidden_permissive():
async def test_invalid_permissive(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
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()
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
await cfg.permissive.add('force_default_on_freeze') cfg.permissive.add('force_default_on_freeze')
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
await cfg.permissive.add('force_metaconfig_on_freeze') cfg.permissive.add('force_metaconfig_on_freeze')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_permissive_option(config_type):
async def test_permissive_option(config_type): od1 = make_description()
descr = make_description() cfg_ori = Config(od1)
async with await Config(descr) as cfg_ori: cfg_ori.property.read_write()
await cfg_ori.property.read_write() cfg = get_config(cfg_ori, config_type)
cfg = await get_config(cfg_ori, config_type)
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
props = frozenset() props = frozenset()
try: try:
await cfg.option('u2').value.get() cfg.option('u2').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.unrestraint.option('u1').permissive.set(frozenset(['disabled'])) cfg_ori.unrestraint.option('u1').permissive.set(frozenset(['disabled']))
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert frozenset(props) == frozenset() assert frozenset(props) == frozenset()
props = frozenset() props = frozenset()
try: try:
await cfg.option('u2').value.get() cfg.option('u2').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.property.add('permissive') cfg_ori.property.add('permissive')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
await cfg.option('u1').value.get() cfg.option('u1').value.get()
props = frozenset() props = frozenset()
try: try:
await cfg.option('u2').value.get() cfg.option('u2').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.property.pop('permissive') cfg_ori.property.remove('permissive')
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert frozenset(props) == frozenset() assert frozenset(props) == frozenset()
props = frozenset() props = frozenset()
try: try:
await cfg.option('u2').value.get() cfg.option('u2').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_permissive_option_cache():
async def test_permissive_option_cache(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write()
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
props = frozenset() props = frozenset()
try: try:
await cfg.option('u2').value.get() cfg.option('u2').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
await cfg.unrestraint.option('u1').permissive.set(frozenset(['disabled'])) cfg.unrestraint.option('u1').permissive.set(frozenset(['disabled']))
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert frozenset(props) == frozenset() assert frozenset(props) == frozenset()
props = frozenset() props = frozenset()
try: try:
await cfg.option('u2').value.get() cfg.option('u2').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
await cfg.property.add('permissive') cfg.property.add('permissive')
await cfg.option('u1').value.get() cfg.option('u1').value.get()
props = frozenset() props = frozenset()
try: try:
await cfg.option('u2').value.get() cfg.option('u2').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
await cfg.property.pop('permissive') cfg.property.remove('permissive')
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert frozenset(props) == frozenset() assert frozenset(props) == frozenset()
props = frozenset() props = frozenset()
try: try:
await cfg.option('u2').value.get() cfg.option('u2').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert set(props) == {'disabled'} assert set(props) == {'disabled'}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_permissive_option_mandatory():
async def test_permissive_option_mandatory(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_only()
await cfg.property.read_only()
props = frozenset() props = frozenset()
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert frozenset(props) == frozenset(['disabled']) assert frozenset(props) == frozenset(['disabled'])
await cfg.unrestraint.option('u1').permissive.set(frozenset(['mandatory', 'disabled'])) cfg.unrestraint.option('u1').permissive.set(frozenset(['mandatory', 'disabled']))
assert await cfg.unrestraint.option('u1').permissive.get() == frozenset(['mandatory', 'disabled']) assert cfg.unrestraint.option('u1').permissive.get() == frozenset(['mandatory', 'disabled'])
await cfg.property.add('permissive') cfg.property.add('permissive')
await cfg.option('u1').value.get() cfg.option('u1').value.get()
await cfg.property.pop('permissive') cfg.property.remove('permissive')
try: try:
await cfg.option('u1').value.get() cfg.option('u1').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert frozenset(props) == frozenset(['disabled']) assert frozenset(props) == frozenset(['disabled'])
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_permissive_option_frozen():
async def test_permissive_option_frozen(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write() cfg.unrestraint.option('u1').permissive.set(frozenset(['frozen', 'disabled']))
await cfg.unrestraint.option('u1').permissive.set(frozenset(['frozen', 'disabled'])) cfg.option('u1').value.set(1)
await cfg.option('u1').value.set(1) assert cfg.option('u1').value.get() == 1
assert await cfg.option('u1').value.get() == 1 cfg.property.add('permissive')
await cfg.property.add('permissive') assert cfg.option('u1').value.get() == 1
assert await cfg.option('u1').value.get() == 1 cfg.property.remove('permissive')
await cfg.property.pop('permissive') assert cfg.option('u1').value.get() == 1
assert await cfg.option('u1').value.get() == 1 # assert not list_sessions()
assert not await list_sessions()
@pytest.mark.asyncio def test_invalid_option_permissive():
async def test_invalid_option_permissive(): od1 = make_description()
descr = make_description() cfg = Config(od1)
async with await Config(descr) as cfg: cfg.property.read_write()
await cfg.property.read_write()
with pytest.raises(TypeError): with pytest.raises(TypeError):
await cfg.unrestraint.option('u1').permissive.set(['frozen', 'disabled']) cfg.unrestraint.option('u1').permissive.set(['frozen', 'disabled'])
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_remove_option_permissive(config_type):
async def test_remove_option_permissive(config_type):
var1 = StrOption('var1', '', u'value', properties=('hidden',)) var1 = StrOption('var1', '', u'value', properties=('hidden',))
od1 = OptionDescription('od1', '', [var1]) od1 = OptionDescription('od1', '', [var1])
descr = OptionDescription('rootod', '', [od1]) od2 = OptionDescription('rootod', '', [od1])
async with await Config(descr) as cfg_ori: cfg_ori = Config(od2)
await cfg_ori.property.read_write() cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('od1.var1').value.get() cfg.option('od1.var1').value.get()
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset(['hidden'])) cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset(['hidden']))
assert await cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset(['hidden']) assert cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset(['hidden'])
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('od1.var1').value.get() == 'value' assert cfg.option('od1.var1').value.get() == 'value'
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset()) cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset())
assert await cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset() assert cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset()
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('od1.var1').value.get() cfg.option('od1.var1').value.get()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_reset_option_permissive(config_type):
async def test_reset_option_permissive(config_type):
var1 = StrOption('var1', '', u'value', properties=('hidden',)) var1 = StrOption('var1', '', u'value', properties=('hidden',))
od1 = OptionDescription('od1', '', [var1]) od1 = OptionDescription('od1', '', [var1])
descr = OptionDescription('rootod', '', [od1]) od2 = OptionDescription('rootod', '', [od1])
async with await Config(descr) as cfg_ori: cfg_ori = Config(od2)
await cfg_ori.property.read_write() cfg_ori.property.read_write()
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('od1.var1').value.get() cfg.option('od1.var1').value.get()
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset(['hidden'])) cfg_ori.forcepermissive.option('od1.var1').permissive.set(frozenset(['hidden']))
assert await cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset(['hidden']) assert cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset(['hidden'])
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
assert await cfg.option('od1.var1').value.get() == 'value' assert cfg.option('od1.var1').value.get() == 'value'
if config_type == 'tiramisu-api': if config_type == 'tiramisu-api':
await cfg.send() cfg.send()
await cfg_ori.forcepermissive.option('od1.var1').permissive.reset() cfg_ori.forcepermissive.option('od1.var1').permissive.reset()
assert await cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset() assert cfg_ori.forcepermissive.option('od1.var1').permissive.get() == frozenset()
cfg = await get_config(cfg_ori, config_type) cfg = get_config(cfg_ori, config_type)
with pytest.raises(PropertiesOptionError): with pytest.raises(PropertiesOptionError):
await cfg.option('od1.var1').value.get() cfg.option('od1.var1').value.get()
assert not await list_sessions() # assert not list_sessions()

1004
tests/test_requires.py
View file

File diff suppressed because it is too large Load diff

43
tests/test_slots.py
View file

@ -16,8 +16,6 @@ from tiramisu.option import ChoiceOption, BoolOption, IntOption, FloatOption,\
StrOption, SymLinkOption, StrOption, IPOption, OptionDescription, \ StrOption, SymLinkOption, StrOption, IPOption, OptionDescription, \
PortOption, NetworkOption, NetmaskOption, DomainnameOption, EmailOption, \ PortOption, NetworkOption, NetmaskOption, DomainnameOption, EmailOption, \
URLOption, FilenameOption URLOption, FilenameOption
from tiramisu.storage import list_sessions, delete_session
from .config import event_loop
def test_slots_option(): def test_slots_option():
@ -86,8 +84,7 @@ def test_slots_option():
del c del c
@pytest.mark.asyncio def test_slots_option_readonly():
async def test_slots_option_readonly():
a = ChoiceOption('a', '', ('a',)) a = ChoiceOption('a', '', ('a',))
b = BoolOption('b', '') b = BoolOption('b', '')
c = IntOption('c', '') c = IntOption('c', '')
@ -118,8 +115,7 @@ async def test_slots_option_readonly():
o._name = 'o' o._name = 'o'
p._name = 'p' p._name = 'p'
q._name = 'q' q._name = 'q'
async with await Config(m) as cfg: Config(m)
pass
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
a._requires = 'a' a._requires = 'a'
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
@ -150,7 +146,7 @@ async def test_slots_option_readonly():
p._requires = 'p' p._requires = 'p'
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
q._requires = 'q' q._requires = 'q'
assert not await list_sessions() # assert not list_sessions()
#def test_slots_description(): #def test_slots_description():
@ -162,47 +158,44 @@ async def test_slots_option_readonly():
# assert slots == set(OptionDescription.__slots__) # assert slots == set(OptionDescription.__slots__)
@pytest.mark.asyncio def test_slots_config():
async def test_slots_config():
od1 = OptionDescription('a', '', []) od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1]) od2 = OptionDescription('a', '', [od1])
async with await Config(od2) as c: cfg = Config(od2)
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
c._config_bag.context.x = 1 cfg._config_bag.context.x = 1
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
c._config_bag.context.cfgimpl_x = 1 cfg._config_bag.context.cfgimpl_x = 1
option_bag = OptionBag() option_bag = OptionBag()
option_bag.set_option(od2, option_bag.set_option(od2,
'a', 'a',
ConfigBag(c._config_bag.context, None, None)) ConfigBag(cfg._config_bag.context, None, None))
sc = await c._config_bag.context.get_subconfig(option_bag) sc = cfg._config_bag.context.get_subconfig(option_bag)
assert isinstance(sc, SubConfig) assert isinstance(sc, SubConfig)
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
sc.x = 1 sc.x = 1
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
sc.cfgimpl_x = 1 sc.cfgimpl_x = 1
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_slots_setting():
async def test_slots_setting():
od1 = OptionDescription('a', '', []) od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1]) od2 = OptionDescription('a', '', [od1])
async with await Config(od2) as c: cfg = Config(od2)
s = c._config_bag.context.cfgimpl_get_settings() s = cfg._config_bag.context.cfgimpl_get_settings()
s s
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
s.x = 1 s.x = 1
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_slots_value():
async def test_slots_value():
od1 = OptionDescription('a', '', []) od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1]) od2 = OptionDescription('a', '', [od1])
async with await Config(od2) as c: cfg = Config(od2)
v = c._config_bag.context.cfgimpl_get_values() v = cfg._config_bag.context.cfgimpl_get_values()
v v
with pytest.raises(AttributeError): with pytest.raises(AttributeError):
v.x = 1 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 from pickle import dumps
import pytest import pytest
import sys, warnings import sys, warnings
from tiramisu.storage import list_sessions
from .config import event_loop
def test_diff_opt(): def test_diff_opt():
@ -25,19 +23,18 @@ def test_diff_opt():
dumps(o1) dumps(o1)
@pytest.mark.asyncio def test_diff_information_config():
async def test_diff_information_config():
b = BoolOption('b', '') b = BoolOption('b', '')
b.impl_set_information('info', 'oh') b.impl_set_information('info', 'oh')
b.impl_set_information('info1', 'oh') b.impl_set_information('info1', 'oh')
b.impl_set_information('info2', 'oh') b.impl_set_information('info2', 'oh')
o = OptionDescription('o', '', [b]) o = OptionDescription('o', '', [b])
o1 = OptionDescription('o1', '', [o]) od1 = OptionDescription('o1', '', [o])
async with await Config(o1) as cfg: cfg = Config(od1)
c = cfg._config_bag.context c = cfg._config_bag.context
with pytest.raises(NotImplementedError): with pytest.raises(NotImplementedError):
dumps(c) dumps(c)
assert not await list_sessions() # assert not list_sessions()
def test_only_optiondescription(): 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, \ from tiramisu import StrOption, IntOption, OptionDescription, submulti, Leadership, Config, \
MetaConfig, undefined, Params, ParamOption, Calculation MetaConfig, undefined, Params, ParamOption, Calculation
from tiramisu.error import LeadershipError from tiramisu.error import LeadershipError
from tiramisu.storage import list_sessions
from .config import event_loop
def return_val(val=None): def return_val(val=None):
@ -28,481 +26,456 @@ def return_list2(value=None):
return [['val', 'val']] return [['val', 'val']]
@pytest.mark.asyncio def test_unknown_multi():
async def test_unknown_multi():
with pytest.raises(ValueError): with pytest.raises(ValueError):
StrOption('multi', '', multi='unknown') StrOption('multi', '', multi='unknown')
@pytest.mark.asyncio def test_submulti():
async def test_submulti():
multi = StrOption('multi', '', multi=submulti) multi = StrOption('multi', '', multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti) multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti) multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
od = OptionDescription('od', '', [multi, multi2, multi3]) od1 = OptionDescription('od', '', [multi, multi2, multi3])
async with await Config(od) as cfg: cfg = Config(od1)
assert await cfg.option('multi').option.ismulti() assert cfg.option('multi').option.ismulti()
assert await cfg.option('multi').option.issubmulti() assert cfg.option('multi').option.issubmulti()
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi').value.get() == [] assert cfg.option('multi').value.get() == []
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi3').value.get() == [['yes']] assert cfg.option('multi3').value.get() == [['yes']]
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_submulti_default_multi_not_list():
async def test_submulti_default_multi_not_list():
with pytest.raises(ValueError): with pytest.raises(ValueError):
StrOption('multi2', '', default_multi='yes', multi=submulti) StrOption('multi2', '', default_multi='yes', multi=submulti)
@pytest.mark.asyncio def test_append_submulti():
async def test_append_submulti():
multi = StrOption('multi', '', multi=submulti) multi = StrOption('multi', '', multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti) multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti) multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
od = OptionDescription('od', '', [multi, multi2, multi3]) od1 = OptionDescription('od', '', [multi, multi2, multi3])
async with await Config(od) as cfg: cfg = Config(od1)
owner = await cfg.owner.get() owner = cfg.owner.get()
assert await cfg.option('multi').value.get() == [] assert cfg.option('multi').value.get() == []
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
await cfg.option('multi').value.set([undefined]) cfg.option('multi').value.set([undefined])
assert await cfg.option('multi').owner.get() == owner assert cfg.option('multi').owner.get() == owner
assert await cfg.option('multi').value.get() == [[]] assert cfg.option('multi').value.get() == [[]]
await cfg.option('multi').value.set([undefined, ['no']]) cfg.option('multi').value.set([undefined, ['no']])
assert await cfg.option('multi').value.get() == [[], ['no']] assert cfg.option('multi').value.get() == [[], ['no']]
# #
assert await cfg.option('multi2').value.get() == [] assert cfg.option('multi2').value.get() == []
assert await cfg.option('multi2').owner.get() == owners.default assert cfg.option('multi2').owner.get() == owners.default
await cfg.option('multi2').value.set([undefined]) cfg.option('multi2').value.set([undefined])
assert await cfg.option('multi2').owner.get() == owner assert cfg.option('multi2').owner.get() == owner
assert await cfg.option('multi2').value.get() == [['yes']] assert cfg.option('multi2').value.get() == [['yes']]
await cfg.option('multi2').value.set([undefined, ['no']]) cfg.option('multi2').value.set([undefined, ['no']])
assert await cfg.option('multi2').value.get() == [['yes'], ['no']] assert cfg.option('multi2').value.get() == [['yes'], ['no']]
# #
assert await cfg.option('multi3').value.get() == [['yes']] assert cfg.option('multi3').value.get() == [['yes']]
assert await cfg.option('multi3').owner.get() == owners.default assert cfg.option('multi3').owner.get() == owners.default
await cfg.option('multi3').value.set([undefined, undefined]) cfg.option('multi3').value.set([undefined, undefined])
assert await cfg.option('multi3').owner.get() == owner assert cfg.option('multi3').owner.get() == owner
assert await cfg.option('multi3').value.get() == [['yes'], []] assert cfg.option('multi3').value.get() == [['yes'], []]
await cfg.option('multi3').value.set([undefined, undefined, ['no']]) cfg.option('multi3').value.set([undefined, undefined, ['no']])
assert await cfg.option('multi3').value.get() == [['yes'], [], ['no']] assert cfg.option('multi3').value.get() == [['yes'], [], ['no']]
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_append_unvalide_submulti():
async def test_append_unvalide_submulti():
multi = StrOption('multi', '', multi=submulti) multi = StrOption('multi', '', multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti) multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti) multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
od = OptionDescription('od', '', [multi, multi2, multi3]) od1 = OptionDescription('od', '', [multi, multi2, multi3])
async with await Config(od) as cfg: cfg = Config(od1)
assert await cfg.option('multi').value.get() == [] assert cfg.option('multi').value.get() == []
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('multi').value.set([[1]]) cfg.option('multi').value.set([[1]])
assert await cfg.option('multi').value.get() == [] assert cfg.option('multi').value.get() == []
assert await cfg.option('multi').owner.get() == owners.default 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): with pytest.raises(ValueError):
await cfg.option('multi2').value.set(['no']) cfg.option('multi2').value.set(['no'])
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi2').value.get() == [] assert cfg.option('multi2').value.get() == []
# #
assert await cfg.option('multi3').value.get() == [['yes']] assert cfg.option('multi3').value.get() == [['yes']]
assert await cfg.option('multi3').owner.get() == owners.default assert cfg.option('multi3').owner.get() == owners.default
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('multi3').value.set([[1]]) cfg.option('multi3').value.set([[1]])
assert await cfg.option('multi3').value.get() == [['yes']] assert cfg.option('multi3').value.get() == [['yes']]
assert await cfg.option('multi3').owner.get() == owners.default assert cfg.option('multi3').owner.get() == owners.default
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_pop_submulti():
async def test_pop_submulti():
multi = StrOption('multi', '', multi=submulti) multi = StrOption('multi', '', multi=submulti)
multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti) multi2 = StrOption('multi2', '', default_multi=['yes'], multi=submulti)
multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti) multi3 = StrOption('multi3', '', default=[['yes']], multi=submulti)
od = OptionDescription('od', '', [multi, multi2, multi3]) od1 = OptionDescription('od', '', [multi, multi2, multi3])
async with await Config(od) as cfg: cfg = Config(od1)
owner = await cfg.owner.get() owner = cfg.owner.get()
assert await cfg.option('multi').value.get() == [] assert cfg.option('multi').value.get() == []
assert await cfg.option('multi3').owner.get() == owners.default assert cfg.option('multi3').owner.get() == owners.default
await cfg.option('multi').value.set([['no', 'yes'], ['peharps']]) cfg.option('multi').value.set([['no', 'yes'], ['peharps']])
assert await cfg.option('multi').owner.get() == owner assert cfg.option('multi').owner.get() == owner
assert await cfg.option('multi').value.get() == [['no', 'yes'], ['peharps']] assert cfg.option('multi').value.get() == [['no', 'yes'], ['peharps']]
# #
assert await cfg.option('multi3').value.get() == [['yes']] assert cfg.option('multi3').value.get() == [['yes']]
assert await cfg.option('multi3').owner.get() == owners.default assert cfg.option('multi3').owner.get() == owners.default
await cfg.option('multi3').value.set([]) cfg.option('multi3').value.set([])
assert await cfg.option('multi').owner.get() == owner assert cfg.option('multi').owner.get() == owner
assert await cfg.option('multi3').value.get() == [] assert cfg.option('multi3').value.get() == []
await cfg.option('multi3').value.reset() cfg.option('multi3').value.reset()
assert await cfg.option('multi3').owner.get() == owners.default assert cfg.option('multi3').owner.get() == owners.default
await cfg.option('multi3').value.set([[]]) cfg.option('multi3').value.set([[]])
assert await cfg.option('multi3').owner.get() == owner assert cfg.option('multi3').owner.get() == owner
assert await cfg.option('multi3').value.get() == [[]] assert cfg.option('multi3').value.get() == [[]]
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_callback_submulti_str():
async def test_callback_submulti_str():
multi = StrOption('multi', '', [[Calculation(return_val)]], multi=submulti, default_multi=[Calculation(return_val)]) multi = StrOption('multi', '', [[Calculation(return_val)]], multi=submulti, default_multi=[Calculation(return_val)])
od = OptionDescription('od', '', [multi]) od1 = OptionDescription('od', '', [multi])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
owner = await cfg.owner.get() owner = cfg.owner.get()
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi').value.get() == [['val']] assert cfg.option('multi').value.get() == [['val']]
await cfg.option('multi').value.set([['val'], undefined]) cfg.option('multi').value.set([['val'], undefined])
assert await cfg.option('multi').owner.get() == owner assert cfg.option('multi').owner.get() == owner
assert await cfg.option('multi').value.get() == [['val'], ['val']] assert cfg.option('multi').value.get() == [['val'], ['val']]
await cfg.option('multi').value.reset() cfg.option('multi').value.reset()
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_callback_submulti_list():
async def test_callback_submulti_list():
multi = StrOption('multi', '', [Calculation(return_list)], multi=submulti, default_multi=Calculation(return_list), properties=('notunique',)) multi = StrOption('multi', '', [Calculation(return_list)], multi=submulti, default_multi=Calculation(return_list), properties=('notunique',))
od = OptionDescription('od', '', [multi]) od1 = OptionDescription('od', '', [multi])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
owner = await cfg.owner.get() owner = cfg.owner.get()
assert await cfg.option('multi').value.get() == [['val', 'val']] assert cfg.option('multi').value.get() == [['val', 'val']]
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
await cfg.option('multi').value.set([['val', 'val'], undefined]) cfg.option('multi').value.set([['val', 'val'], undefined])
#assert await cfg.option('multi').owner.get() == owner #assert cfg.option('multi').owner.get() == owner
#assert await cfg.option('multi').value.get() == [['val', 'val'], ['val', 'val']] #assert cfg.option('multi').value.get() == [['val', 'val'], ['val', 'val']]
#await cfg.option('multi').value.set([['val', 'val'], undefined, undefined]) #cfg.option('multi').value.set([['val', 'val'], undefined, undefined])
#assert await cfg.option('multi').value.get() == [['val', 'val'], ['val', 'val'], ['val', 'val']] #assert cfg.option('multi').value.get() == [['val', 'val'], ['val', 'val'], ['val', 'val']]
#await cfg.option('multi').value.reset() #cfg.option('multi').value.reset()
#assert await cfg.option('multi').owner.get() == owners.default #assert cfg.option('multi').owner.get() == owners.default
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_callback_submulti_list_list():
async def test_callback_submulti_list_list():
multi = StrOption('multi', '', Calculation(return_list2), multi=submulti, properties=('notunique',)) multi = StrOption('multi', '', Calculation(return_list2), multi=submulti, properties=('notunique',))
od = OptionDescription('od', '', [multi]) od1 = OptionDescription('od', '', [multi])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
owner = await cfg.owner.get() owner = cfg.owner.get()
assert await cfg.option('multi').value.get() == [['val', 'val']] assert cfg.option('multi').value.get() == [['val', 'val']]
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
await cfg.option('multi').value.set([['val', 'val'], undefined]) cfg.option('multi').value.set([['val', 'val'], undefined])
assert await cfg.option('multi').owner.get() == owner assert cfg.option('multi').owner.get() == owner
assert await cfg.option('multi').value.get() == [['val', 'val'], []] assert cfg.option('multi').value.get() == [['val', 'val'], []]
await cfg.option('multi').value.reset() cfg.option('multi').value.reset()
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_groups_with_leader_submulti():
async def test_groups_with_leader_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
assert interface1.impl_get_group_type() == groups.leadership assert interface1.impl_get_group_type() == groups.leadership
@pytest.mark.asyncio def test_groups_with_leader_in_config_submulti():
async def test_groups_with_leader_in_config_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
od = OptionDescription('root', '', [interface1]) od1 = OptionDescription('root', '', [interface1])
async with await Config(od) as cfg: cfg = Config(od1)
pass
assert interface1.impl_get_group_type() == groups.leadership assert interface1.impl_get_group_type() == groups.leadership
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_values_with_leader_and_followers_submulti():
async def test_values_with_leader_and_followers_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1]) od1 = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
owner = await cfg.owner.get() owner = cfg.owner.get()
assert interface1.impl_get_group_type() == groups.leadership assert interface1.impl_get_group_type() == groups.leadership
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default assert 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"]) 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 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 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 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 assert 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"]) 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 cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == []
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == [] assert 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']) 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 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.netmask_admin_eth0', 1).value.get() == []
with pytest.raises(ValueError): 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): 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']])
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_values_with_leader_and_followers_submulti_default_multi():
async def test_values_with_leader_and_followers_submulti_default_multi():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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']) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1]) od1 = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
owner = await cfg.owner.get() owner = cfg.owner.get()
assert interface1.impl_get_group_type() == groups.leadership assert interface1.impl_get_group_type() == groups.leadership
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default assert 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"]) 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 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'] assert 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"]) 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']) 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 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 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 not list_sessions()
@pytest.mark.asyncio def test_reset_values_with_leader_and_followers_submulti():
async def test_reset_values_with_leader_and_followers_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1]) od1 = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
owner = await cfg.owner.get() owner = cfg.owner.get()
assert interface1.impl_get_group_type() == groups.leadership assert interface1.impl_get_group_type() == groups.leadership
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default assert 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']) 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 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 assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owners.default
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset() 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 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').value.get() == []
# #
await 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'])
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'])
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner assert 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 assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owner
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset() 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 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').value.get() == []
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_values_with_leader_and_followers_follower_submulti():
async def test_values_with_leader_and_followers_follower_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, properties=('notunique',)) 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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1]) od1 = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
with pytest.raises(LeadershipError): with pytest.raises(LeadershipError):
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'])
await 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'])
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'])
await 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.set(['255.255.255.0', '255.255.255.0'])
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.reset() 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']) 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']) 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 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.netmask_admin_eth0', 1).value.get() == []
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'])
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_values_with_leader_and_leadership_submulti():
async def test_values_with_leader_and_leadership_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, properties=('notunique',)) 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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1]) od1 = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
await 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"])
await 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.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']) 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']) 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 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'] assert 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) 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 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'] assert 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() cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == [] assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_values_with_leader_owner_submulti():
async def test_values_with_leader_owner_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1]) od1 = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
owner = await cfg.owner.get() owner = cfg.owner.get()
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default assert 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']) 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 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 assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == owners.default
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.reset() 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 cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owners.default
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_values_with_leader_disabled_submulti():
async def test_values_with_leader_disabled_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, properties=('notunique',)) 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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1]) od1 = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
await 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'])
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0) 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']) 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']) 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() cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.reset()
await cfg.option('ip_admin_eth0.netmask_admin_eth0').property.add('disabled') 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']) 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) cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(1)
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0) cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
#delete with value in disabled var #delete with value in disabled var
await cfg.unrestraint.option('ip_admin_eth0.netmask_admin_eth0').property.pop('disabled') cfg.unrestraint.option('ip_admin_eth0.netmask_admin_eth0').property.remove('disabled')
await 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'])
await 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.set(['192.168.230.145'])
await cfg.unrestraint.option('ip_admin_eth0.netmask_admin_eth0').property.add('disabled') cfg.unrestraint.option('ip_admin_eth0.netmask_admin_eth0').property.add('disabled')
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0) cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_leader_is_submulti():
async def test_leader_is_submulti():
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
maconfig = OptionDescription('toto', '', [interface1]) od1 = OptionDescription('toto', '', [interface1])
async with await Config(maconfig) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
owner = await cfg.owner.get() owner = cfg.owner.get()
assert interface1.impl_get_group_type() == groups.leadership assert interface1.impl_get_group_type() == groups.leadership
assert await cfg.option('ip_admin_eth0.ip_admin_eth0').owner.isdefault() assert 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"]]) 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 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 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 cfg.option('ip_admin_eth0.ip_admin_eth0').owner.get() == owner
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.isdefault() assert 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"]]) 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 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 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"]]) 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').value.get() == [["192.168.230.145", '192.168.1.1'], ["192.168.230.147"]]
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.1', '192.168.1.1']) cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.1', '192.168.1.1'])
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_callback_submulti():
async def test_callback_submulti():
multi = StrOption('multi', '', multi=submulti) multi = StrOption('multi', '', multi=submulti)
multi2 = StrOption('multi2', '', Calculation(return_val, Params(ParamOption(multi))), multi=submulti) multi2 = StrOption('multi2', '', Calculation(return_val, Params(ParamOption(multi))), multi=submulti)
od = OptionDescription('multi', '', [multi, multi2]) od1 = OptionDescription('multi', '', [multi, multi2])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
owner = await cfg.owner.get() owner = cfg.owner.get()
assert await cfg.option('multi').owner.get() == owners.default assert cfg.option('multi').owner.get() == owners.default
assert await cfg.option('multi').value.get() == [] assert cfg.option('multi').value.get() == []
assert await cfg.option('multi2').value.get() == [] assert cfg.option('multi2').value.get() == []
await cfg.option('multi').value.set([['val']]) cfg.option('multi').value.set([['val']])
assert await cfg.option('multi').owner.get() == owner assert cfg.option('multi').owner.get() == owner
assert await cfg.option('multi2').owner.get() == owners.default assert cfg.option('multi2').owner.get() == owners.default
assert await cfg.option('multi').value.get() == [['val']] assert cfg.option('multi').value.get() == [['val']]
assert await cfg.option('multi2').value.get() == [['val']] assert cfg.option('multi2').value.get() == [['val']]
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_callback_submulti_follower():
async def test_callback_submulti_follower():
multi = StrOption('multi', '', multi=True) multi = StrOption('multi', '', multi=True)
multi2 = StrOption('multi2', '', Calculation(return_list), multi=submulti) multi2 = StrOption('multi2', '', Calculation(return_list), multi=submulti)
od = Leadership('multi', '', [multi, multi2]) od = Leadership('multi', '', [multi, multi2])
od = OptionDescription('multi', '', [od]) od1 = OptionDescription('multi', '', [od])
async with await Config(od) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
assert await cfg.option('multi.multi').value.get() == [] assert cfg.option('multi.multi').value.get() == []
await cfg.option('multi.multi').value.set(['val']) cfg.option('multi.multi').value.set(['val'])
assert await cfg.option('multi.multi2', 0).value.get() == ['val', 'val'] assert cfg.option('multi.multi2', 0).value.get() == ['val', 'val']
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_submulti_unique():
async def test_submulti_unique():
i = IntOption('int', '', multi=submulti, properties=('unique',)) i = IntOption('int', '', multi=submulti, properties=('unique',))
o = OptionDescription('od', '', [i]) od1 = OptionDescription('od', '', [i])
async with await Config(o) as cfg: cfg = Config(od1)
assert await cfg.option('int').value.get() == [] assert cfg.option('int').value.get() == []
await cfg.option('int').value.set([[0]]) cfg.option('int').value.set([[0]])
assert await cfg.option('int').value.get() == [[0]] assert cfg.option('int').value.get() == [[0]]
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('int').value.set([[0, 0]]) cfg.option('int').value.set([[0, 0]])
await cfg.option('int').value.set([[0], [0]]) cfg.option('int').value.set([[0], [0]])
with pytest.raises(ValueError): with pytest.raises(ValueError):
await cfg.option('int').value.set([[1, 0, 2, 3, 4, 5, 6, 0, 7], [0]]) 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]]) cfg.option('int').value.set([[0, 4, 5, 6], [0]])
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_multi_submulti_meta():
async def test_multi_submulti_meta():
multi = StrOption('multi', '', multi=submulti) multi = StrOption('multi', '', multi=submulti)
od = OptionDescription('od', '', [multi]) od1 = OptionDescription('od', '', [multi])
async with await Config(od, session_id='cfg') as cfg: cfg = Config(od1, name='cfg')
await cfg.property.read_write() cfg.property.read_write()
async with await Config(od, session_id='cfg2') as cfg2: cfg2 = Config(od1)
await cfg2.property.read_write() cfg2.property.read_write()
async with await MetaConfig([cfg, cfg2]) as meta: meta = MetaConfig([cfg, cfg2])
await meta.property.read_write() meta.property.read_write()
await meta.option('multi').value.set([['val']]) meta.option('multi').value.set([['val']])
assert await meta.option('multi').value.get() == [['val']] assert meta.option('multi').value.get() == [['val']]
newcfg = await meta.config('cfg') newcfg = meta.config('cfg')
await newcfg.option('multi').value.set([['val', None]]) newcfg.option('multi').value.set([['val', None]])
assert await cfg.option('multi').value.get() == [['val', None]] assert cfg.option('multi').value.get() == [['val', None]]
newcfg = await meta.config('cfg') newcfg = meta.config('cfg')
assert await newcfg.option('multi').value.get() == [['val', None]] assert newcfg.option('multi').value.get() == [['val', None]]
assert await meta.option('multi').value.get() == [['val']] assert meta.option('multi').value.get() == [['val']]
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_multi_submulti_meta_no_cache():
async def test_multi_submulti_meta_no_cache():
multi = StrOption('multi', '', multi=submulti) multi = StrOption('multi', '', multi=submulti)
multi = StrOption('multi', '', multi=submulti) multi = StrOption('multi', '', multi=submulti)
od = OptionDescription('od', '', [multi]) od1 = OptionDescription('od', '', [multi])
async with await Config(od, session_id='cfg') as cfg: cfg = Config(od1, name='cfg')
await cfg.property.read_write() cfg.property.read_write()
async with await Config(od, session_id='cfg2') as cfg2: cfg2 = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
async with await MetaConfig([cfg, cfg2]) as meta: meta = MetaConfig([cfg, cfg2])
await meta.property.read_write() meta.property.read_write()
await meta.property.pop('cache') meta.property.remove('cache')
await meta.option('multi').value.set([['val']]) meta.option('multi').value.set([['val']])
assert await meta.option('multi').value.get() == [['val']] assert meta.option('multi').value.get() == [['val']]
newcfg = await meta.config('cfg') newcfg = meta.config('cfg')
await newcfg.option('multi').value.set([['val', None]]) newcfg.option('multi').value.set([['val', None]])
assert await cfg.option('multi').value.get() == [['val', None]] assert cfg.option('multi').value.get() == [['val', None]]
newcfg = await meta.config('cfg') newcfg = meta.config('cfg')
assert await newcfg.option('multi').value.get() == [['val', None]] assert newcfg.option('multi').value.get() == [['val', None]]
assert await meta.option('multi').value.get() == [['val']] assert meta.option('multi').value.get() == [['val']]
assert not await list_sessions() # 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, \ from tiramisu import BoolOption, StrOption, SymLinkOption, \
OptionDescription, Leadership, Config, Calculation, calc_value, Params, ParamOption, ParamValue 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.setting import groups, owners
from tiramisu.storage import list_sessions
from .config import event_loop
def return_value(): def return_value():
@ -17,129 +15,120 @@ def return_value():
#____________________________________________________________ #____________________________________________________________
@pytest.mark.asyncio def test_symlink_option(config_type):
async def test_symlink_option(config_type):
boolopt = BoolOption("b", "", default=False) boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "", od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])]) [linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.option('s1.b').value.get() is False assert cfg.option('s1.b').value.get() is False
await cfg.option("s1.b").value.set(True) cfg.option("s1.b").value.set(True)
await cfg.option("s1.b").value.set(False) cfg.option("s1.b").value.set(False)
assert await cfg.option('s1.b').value.get() is False assert cfg.option('s1.b').value.get() is False
assert await cfg.option('c').value.get() is False assert cfg.option('c').value.get() is False
await cfg.option('s1.b').value.set(True) cfg.option('s1.b').value.set(True)
assert await cfg.option('s1.b').value.get() is True assert cfg.option('s1.b').value.get() is True
assert await cfg.option('c').value.get() is True assert cfg.option('c').value.get() is True
await cfg.option('s1.b').value.set(False) cfg.option('s1.b').value.set(False)
assert await cfg.option('s1.b').value.get() is False assert cfg.option('s1.b').value.get() is False
assert await cfg.option('c').value.get() is False assert cfg.option('c').value.get() is False
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_assign_option(config_type):
async def test_symlink_assign_option(config_type):
boolopt = BoolOption("b", "", default=False) boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "", od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])]) [linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
await cfg.option('c').value.set(True) cfg.option('c').value.set(True)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_del_option(config_type):
async def test_symlink_del_option(config_type):
boolopt = BoolOption("b", "", default=False) boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "", od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])]) [linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
await cfg.option('c').value.reset() cfg.option('c').value.reset()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_addproperties():
async def test_symlink_addproperties():
boolopt = BoolOption('b', '', default=True, properties=('test',)) boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription('opt', '', [boolopt, linkopt]) od1 = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
with pytest.raises(TypeError): with pytest.raises(TypeError):
await cfg.option('c').property.add('new') cfg.option('c').property.add('new')
try: try:
await cfg.option('c').property.reset() cfg.option('c').property.reset()
except AssertionError: except AssertionError:
pass pass
else: else:
raise Exception('must raise') raise Exception('must raise')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_getpermissive():
async def test_symlink_getpermissive():
boolopt = BoolOption('b', '', default=True, properties=('test',)) boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription('opt', '', [boolopt, linkopt]) od1 = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
await cfg.option('b').permissive.set(frozenset(['perm'])) cfg.option('b').permissive.set(frozenset(['perm']))
await cfg.option('c').permissive.get() == frozenset(['perm']) cfg.option('c').permissive.get() == frozenset(['perm'])
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_addpermissives():
async def test_symlink_addpermissives():
boolopt = BoolOption('b', '', default=True, properties=('test',)) boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription('opt', '', [boolopt, linkopt]) od1 = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
with pytest.raises(TypeError): with pytest.raises(TypeError):
await cfg.option('c').permissive.set(frozenset(['new'])) cfg.option('c').permissive.set(frozenset(['new']))
try: try:
await cfg.option('c').permissive.reset() cfg.option('c').permissive.reset()
except AssertionError: except AssertionError:
pass pass
else: else:
raise Exception('must raise') raise Exception('must raise')
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_getproperties():
async def test_symlink_getproperties():
boolopt = BoolOption('b', '', default=True, properties=('test',)) boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription('opt', '', [boolopt, linkopt]) od1 = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
assert boolopt.impl_getproperties() == linkopt.impl_getproperties() == {'test'} assert boolopt.impl_getproperties() == linkopt.impl_getproperties() == {'test'}
assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False # assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_getcallback():
async def test_symlink_getcallback():
boolopt = BoolOption('b', '', Calculation(return_value)) boolopt = BoolOption('b', '', Calculation(return_value))
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription('opt', '', [boolopt, linkopt]) od1 = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
#assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == True #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_get_callback() == linkopt.impl_get_callback() == (return_value, None)
assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False # assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_requires(config_type):
async def test_symlink_requires(config_type):
boolopt = BoolOption('b', '', default=True) boolopt = BoolOption('b', '', default=True)
disabled_property = Calculation(calc_value, disabled_property = Calculation(calc_value,
Params(ParamValue('disabled'), Params(ParamValue('disabled'),
@ -147,86 +136,82 @@ async def test_symlink_requires(config_type):
'expected': ParamValue(False)})) 'expected': ParamValue(False)}))
stropt = StrOption('s', '', properties=(disabled_property,)) stropt = StrOption('s', '', properties=(disabled_property,))
linkopt = SymLinkOption("c", stropt) linkopt = SymLinkOption("c", stropt)
descr = OptionDescription('opt', '', [boolopt, stropt, linkopt]) od1 = OptionDescription('opt', '', [boolopt, stropt, linkopt])
async with await Config(descr) as cfg: cfg = Config(od1)
await cfg.property.read_write() cfg.property.read_write()
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.option('b').value.get() is True assert cfg.option('b').value.get() is True
assert await cfg.option('s').value.get() is None assert cfg.option('s').value.get() is None
assert await cfg.option('c').value.get() is None assert cfg.option('c').value.get() is None
await cfg.option('b').value.set(False) cfg.option('b').value.set(False)
# #
props = [] props = []
try: try:
await cfg.option('s').value.get() cfg.option('s').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert props == {'disabled'} assert props == {'disabled'}
# #
props = [] props = []
try: try:
await cfg.option('c').value.get() cfg.option('c').value.get()
except PropertiesOptionError as err: except PropertiesOptionError as err:
props = err.proptype props = err.proptype
assert props == {'disabled'} assert props == {'disabled'}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_multi(config_type):
async def test_symlink_multi(config_type):
boolopt = BoolOption("b", "", default=[False], multi=True) boolopt = BoolOption("b", "", default=[False], multi=True)
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "", od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])]) [linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.option('s1.b').value.get() == [False] assert cfg.option('s1.b').value.get() == [False]
assert await cfg.option('c').value.get() == [False] assert cfg.option('c').value.get() == [False]
await cfg.option('s1.b').value.set([True]) cfg.option('s1.b').value.set([True])
assert await cfg.option('s1.b').value.get() == [True] assert cfg.option('s1.b').value.get() == [True]
assert await cfg.option('c').value.get() == [True] assert cfg.option('c').value.get() == [True]
await cfg.option('s1.b').value.set([False]) cfg.option('s1.b').value.set([False])
assert await cfg.option('s1.b').value.get() == [False] assert cfg.option('s1.b').value.get() == [False]
assert await cfg.option('c').value.get() == [False] assert cfg.option('c').value.get() == [False]
await cfg.option('s1.b').value.set([False, True]) cfg.option('s1.b').value.set([False, True])
assert await cfg.option('s1.b').value.get() == [False, True] assert cfg.option('s1.b').value.get() == [False, True]
assert await cfg.option('c').value.get() == [False, True] assert cfg.option('c').value.get() == [False, True]
assert boolopt.impl_is_multi() is True assert boolopt.impl_is_multi() is True
assert linkopt.impl_is_multi() is True assert linkopt.impl_is_multi() is True
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_assign(config_type):
async def test_symlink_assign(config_type):
boolopt = BoolOption("b", "", default=False) boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "", od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])]) [linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
with pytest.raises(ConfigError): with pytest.raises(ConfigError):
await cfg.option('c').value.set(True) cfg.option('c').value.set(True)
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_owner(config_type):
async def test_symlink_owner(config_type):
boolopt = BoolOption("b", "", default=False) boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "", od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])]) [linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.option('s1.b').owner.isdefault() assert cfg.option('s1.b').owner.isdefault()
assert await cfg.option('c').owner.isdefault() assert cfg.option('c').owner.isdefault()
await cfg.option('s1.b').value.set(True) cfg.option('s1.b').value.set(True)
assert not await cfg.option('s1.b').owner.isdefault() assert not cfg.option('s1.b').owner.isdefault()
assert not await cfg.option('c').owner.isdefault() assert not cfg.option('c').owner.isdefault()
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_get_information():
async def test_symlink_get_information():
boolopt = BoolOption("b", "", default=False) boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
boolopt.impl_set_information('test', 'test') boolopt.impl_set_information('test', 'test')
@ -237,8 +222,7 @@ async def test_symlink_get_information():
assert linkopt.impl_get_information('test') == 'test2' assert linkopt.impl_get_information('test') == 'test2'
@pytest.mark.asyncio def test_symlink_leader():
async def test_symlink_leader():
a = StrOption('a', "", multi=True) a = StrOption('a', "", multi=True)
ip_admin_eth0 = SymLinkOption('ip_admin_eth0', a) ip_admin_eth0 = SymLinkOption('ip_admin_eth0', a)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "", multi=True) 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]) Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
@pytest.mark.asyncio def test_symlink_followers():
async def test_symlink_followers():
a = StrOption('a', "", multi=True) a = StrOption('a', "", multi=True)
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = SymLinkOption('netmask_admin_eth0', a) 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]) Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
@pytest.mark.asyncio def test_symlink_with_leader(config_type):
async def test_symlink_with_leader(config_type):
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
leader = SymLinkOption('leader', ip_admin_eth0) leader = SymLinkOption('leader', ip_admin_eth0)
od = OptionDescription('root', '', [interface1, leader]) od1 = OptionDescription('root', '', [interface1, leader])
async with await Config(od) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'leader': []} assert 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']) 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 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() 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 def test_symlink_with_follower(config_type):
async def test_symlink_with_follower(config_type):
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True) 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) 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]) interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
follower = SymLinkOption('follower', netmask_admin_eth0) follower = SymLinkOption('follower', netmask_admin_eth0)
od = OptionDescription('root', '', [interface1, follower]) od1 = OptionDescription('root', '', [interface1, follower])
async with await Config(od) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'follower': []} assert 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']) 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]} 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 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 cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).owner.get() == 'default'
assert await cfg.option('follower', 0).owner.get() == 'default' assert cfg.option('follower', 0).owner.get() == 'default'
assert await cfg.option('follower', 1).owner.get() == 'default' assert cfg.option('follower', 1).owner.get() == 'default'
assert await cfg.option('follower').owner.get() == ['default', 'default'] assert cfg.option('follower').owner.get() == ['default', 'default']
# #
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None assert 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 cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == None
assert await cfg.option('follower', 0).value.get() == None assert cfg.option('follower', 0).value.get() == None
assert await cfg.option('follower', 1).value.get() == None assert cfg.option('follower', 1).value.get() == None
assert await cfg.option('follower').value.get() == [None, None] assert cfg.option('follower').value.get() == [None, None]
# #
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('val3') 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']} 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 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 cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == 'val3'
assert await cfg.option('follower', 0).value.get() == None assert cfg.option('follower', 0).value.get() == None
assert await cfg.option('follower', 1).value.get() == 'val3' assert cfg.option('follower', 1).value.get() == 'val3'
assert await cfg.option('follower').value.get() == [None, 'val3'] assert cfg.option('follower').value.get() == [None, 'val3']
# #
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == 'default' assert 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 cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).owner.get() == 'user'
assert await cfg.option('follower', 0).owner.get() == 'default' assert cfg.option('follower', 0).owner.get() == 'default'
assert await cfg.option('follower', 1).owner.get() == 'user' assert cfg.option('follower', 1).owner.get() == 'user'
assert await cfg.option('follower').owner.get() == ['default', 'user'] assert cfg.option('follower').owner.get() == ['default', 'user']
assert not await list_sessions() # assert not list_sessions()
#____________________________________________________________ #____________________________________________________________
@pytest.mark.asyncio def test_symlink_dependency():
async def test_symlink_dependency():
boolopt = BoolOption("b", "", default=False) boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "", od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])]) [linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg: cfg = Config(od1)
assert await cfg.option('s1.b').option.has_dependency() is False assert cfg.option('s1.b').option.has_dependency() is False
assert await cfg.option('c').option.has_dependency() is True assert cfg.option('c').option.has_dependency() is True
assert await cfg.option('s1.b').option.has_dependency(False) is True assert cfg.option('s1.b').option.has_dependency(False) is True
assert await cfg.option('c').option.has_dependency(False) is False assert cfg.option('c').option.has_dependency(False) is False
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_makedict(config_type):
async def test_symlink_makedict(config_type):
boolopt = BoolOption("b", "", default=False) boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "", od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])]) [linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
assert await cfg.value.dict() == {'c': False, 's1.b': False} assert cfg.value.dict() == {'c': False, 's1.b': False}
await cfg.option('s1.b').value.set(True) cfg.option('s1.b').value.set(True)
assert await cfg.value.dict() == {'c': True, 's1.b': True} assert cfg.value.dict() == {'c': True, 's1.b': True}
assert not await list_sessions() # assert not list_sessions()
@pytest.mark.asyncio def test_symlink_list(config_type):
async def test_symlink_list(config_type):
boolopt = BoolOption("b", "", default=False) boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt) linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "", od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])]) [linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg: cfg = Config(od1)
cfg = await get_config(cfg, config_type) cfg = get_config(cfg, config_type)
list_opt = [] list_opt = []
for opt in await cfg.option.list(): for opt in cfg.option.list():
list_opt.append(await opt.option.path()) list_opt.append(opt.option.path())
assert list_opt == ['c'] assert list_opt == ['c']
# #
list_opt = [] list_opt = []
for opt in await cfg.option.list(recursive=True): for opt in cfg.option.list(recursive=True):
list_opt.append(await opt.option.path()) list_opt.append(opt.option.path())
assert list_opt == ['c', 's1.b'] 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 .api import Config, MetaConfig, GroupConfig, MixConfig
from .option import __all__ as all_options from .option import __all__ as all_options
from .setting import owners, groups, undefined from .setting import owners, groups, undefined
from .storage import default_storage, Storage, list_sessions, \
delete_session
allfuncs = ['Calculation', allfuncs = ['Calculation',
@ -46,10 +44,6 @@ allfuncs = ['Calculation',
'undefined', 'undefined',
'owners', 'owners',
'groups', 'groups',
'default_storage',
'Storage',
'list_sessions',
'delete_session',
'calc_value', 'calc_value',
'calc_value_property_help', 'calc_value_property_help',
'valid_ip_netmask', 'valid_ip_netmask',

1188
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

52
tiramisu/autolib.py
View file

@ -19,7 +19,6 @@
# ____________________________________________________________ # ____________________________________________________________
"enables us to carry out a calculation and return an option's value" "enables us to carry out a calculation and return an option's value"
from typing import Any, Optional, Union, Callable, Dict, List from typing import Any, Optional, Union, Callable, Dict, List
from types import CoroutineType
from itertools import chain from itertools import chain
from .error import PropertiesOptionError, ConfigError, LeadershipError, ValueWarning from .error import PropertiesOptionError, ConfigError, LeadershipError, ValueWarning
@ -168,7 +167,7 @@ class Calculation:
if warnings_only is True: if warnings_only is True:
self.warnings_only = warnings_only self.warnings_only = warnings_only
async def execute(self, def execute(self,
option_bag: OptionBag, option_bag: OptionBag,
leadership_must_have_index: bool=False, leadership_must_have_index: bool=False,
orig_value: Any=undefined, orig_value: Any=undefined,
@ -176,7 +175,7 @@ class Calculation:
force_value_warning: bool=False, force_value_warning: bool=False,
for_settings: bool=False, for_settings: bool=False,
) -> Any: ) -> Any:
return await carry_out_calculation(option_bag.option, return carry_out_calculation(option_bag.option,
callback=self.function, callback=self.function,
callback_params=self.params, callback_params=self.params,
index=option_bag.index, index=option_bag.index,
@ -188,17 +187,17 @@ class Calculation:
for_settings=for_settings, for_settings=for_settings,
) )
async def help(self, def help(self,
option_bag: OptionBag, option_bag: OptionBag,
leadership_must_have_index: bool=False, leadership_must_have_index: bool=False,
for_settings: bool=False, for_settings: bool=False,
) -> str: ) -> str:
if not self.help_function: if not self.help_function:
return await self.execute(option_bag, return self.execute(option_bag,
leadership_must_have_index=leadership_must_have_index, leadership_must_have_index=leadership_must_have_index,
for_settings=for_settings, for_settings=for_settings,
) )
return await carry_out_calculation(option_bag.option, return carry_out_calculation(option_bag.option,
callback=self.help_function, callback=self.help_function,
callback_params=self.params, callback_params=self.params,
index=option_bag.index, index=option_bag.index,
@ -223,7 +222,7 @@ class Break(Exception):
pass pass
async def manager_callback(callbk: Param, def manager_callback(callbk: Param,
option, option,
index: Optional[int], index: Optional[int],
orig_value, orig_value,
@ -244,7 +243,7 @@ async def manager_callback(callbk: Param,
return index return index
return None 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 # index must be apply only if follower
is_follower = option.impl_is_follower() is_follower = option.impl_is_follower()
apply_index = calc_index(callbk, index, is_follower) apply_index = calc_index(callbk, index, is_follower)
@ -252,11 +251,11 @@ async def manager_callback(callbk: Param,
if config_bag is undefined: if config_bag is undefined:
return undefined return undefined
path = option.impl_getpath() path = option.impl_getpath()
option_bag = await get_option_bag(config_bag, option_bag = get_option_bag(config_bag,
option, option,
apply_index, apply_index,
True) True)
new_value = await get_value(callbk, option_bag, path) new_value = get_value(callbk, option_bag, path)
if apply_index is None and is_follower: if apply_index is None and is_follower:
new_value[index] = value new_value[index] = value
value = new_value value = new_value
@ -264,13 +263,13 @@ async def manager_callback(callbk: Param,
value = value[apply_index] value = value[apply_index]
return value return value
async def get_value(callbk, def get_value(callbk,
option_bag, option_bag,
path, path,
): ):
try: try:
# get value # get value
value = await config_bag.context.getattr(path, value = config_bag.context.getattr(path,
option_bag) option_bag)
except PropertiesOptionError as err: except PropertiesOptionError as err:
# raise PropertiesOptionError (which is catched) because must not add value None in carry_out_calculation # raise PropertiesOptionError (which is catched) because must not add value None in carry_out_calculation
@ -290,7 +289,7 @@ async def manager_callback(callbk: Param,
raise ConfigError(_(f'unable to get value for calculating "{option_bag.option.impl_get_display_name()}", {err}')) from err raise ConfigError(_(f'unable to get value for calculating "{option_bag.option.impl_get_display_name()}", {err}')) from err
return value return value
async def get_option_bag(config_bag, def get_option_bag(config_bag,
opt, opt,
index_, index_,
self_calc): self_calc):
@ -306,12 +305,12 @@ async def manager_callback(callbk: Param,
index_, index_,
config_bag) config_bag)
if not self_calc: if not self_calc:
option_bag.properties = await config_bag.context.cfgimpl_get_settings().getproperties(option_bag) option_bag.properties = config_bag.context.cfgimpl_get_settings().getproperties(option_bag)
else: else:
option_bag.config_bag.unrestraint() option_bag.config_bag.unrestraint()
option_bag.config_bag.remove_validation() option_bag.config_bag.remove_validation()
# if we are in properties calculation, cannot calculated properties # if we are in properties calculation, cannot calculated properties
option_bag.properties = await config_bag.context.cfgimpl_get_settings().getproperties(option_bag, option_bag.properties = config_bag.context.cfgimpl_get_settings().getproperties(option_bag,
apply_requires=False) apply_requires=False)
return option_bag return option_bag
@ -328,7 +327,7 @@ async def manager_callback(callbk: Param,
else: else:
option_bag = None option_bag = None
try: try:
return await config_bag.context.impl_get_information(config_bag, return config_bag.context.impl_get_information(config_bag,
option_bag, option_bag,
callbk.information_name, callbk.information_name,
callbk.default_value, callbk.default_value,
@ -349,7 +348,7 @@ async def manager_callback(callbk: Param,
if isinstance(callbk, ParamSelfOption): if isinstance(callbk, ParamSelfOption):
if leadership_must_have_index and option.impl_is_follower() and index is None: if leadership_must_have_index and option.impl_is_follower() and index is None:
raise Break() 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: if not callbk.todict:
return value return value
return {'name': option.impl_get_display_name(), return {'name': option.impl_get_display_name(),
@ -387,7 +386,7 @@ async def manager_callback(callbk: Param,
dynopt = callbk_option.getsubdyn() dynopt = callbk_option.getsubdyn()
rootpath = dynopt.impl_getpath() rootpath = dynopt.impl_getpath()
subpaths = [rootpath] + callbk_option.impl_getpath()[len(rootpath) + 1:].split('.')[:-1] 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) path_suffix = dynopt.convert_suffix_to_path(suffix)
subpath = '.'.join([subp + path_suffix for subp in subpaths]) subpath = '.'.join([subp + path_suffix for subp in subpaths])
doption = callbk_option.to_dynoption(subpath, doption = callbk_option.to_dynoption(subpath,
@ -418,11 +417,11 @@ async def manager_callback(callbk: Param,
index_ = None index_ = None
with_index = False with_index = False
path = callbk_option.impl_getpath() path = callbk_option.impl_getpath()
option_bag = await get_option_bag(config_bag, option_bag = get_option_bag(config_bag,
callbk_option, callbk_option,
index_, index_,
False) False)
value = await get_value(callbk, value = get_value(callbk,
option_bag, option_bag,
path, path,
) )
@ -440,7 +439,7 @@ async def manager_callback(callbk: Param,
option.impl_get_display_name())) option.impl_get_display_name()))
async def carry_out_calculation(option, def carry_out_calculation(option,
callback: Callable, callback: Callable,
callback_params: Optional[Params], callback_params: Optional[Params],
index: Optional[int], index: Optional[int],
@ -474,7 +473,7 @@ async def carry_out_calculation(option,
if callback_params: if callback_params:
for key, callbk in chain(fake_items(callback_params.args), callback_params.kwargs.items()): for key, callbk in chain(fake_items(callback_params.args), callback_params.kwargs.items()):
try: try:
value = await manager_callback(callbk, value = manager_callback(callbk,
option, option,
index, index,
orig_value, orig_value,
@ -498,7 +497,7 @@ async def carry_out_calculation(option,
kwargs[key] = {'propertyerror': str(err)} kwargs[key] = {'propertyerror': str(err)}
except Break: except Break:
continue continue
ret = await calculate(option, ret = calculate(option,
callback, callback,
allow_value_error, allow_value_error,
force_value_warning, force_value_warning,
@ -524,7 +523,7 @@ async def carry_out_calculation(option,
return ret return ret
async def calculate(option, def calculate(option,
callback: Callable, callback: Callable,
allow_value_error: bool, allow_value_error: bool,
force_value_warning: bool, force_value_warning: bool,
@ -539,10 +538,7 @@ async def calculate(option,
""" """
try: try:
ret = callback(*args, **kwargs) return callback(*args, **kwargs)
if isinstance(ret, CoroutineType):
ret = await ret
return ret
except (ValueError, ValueWarning) as err: except (ValueError, ValueWarning) as err:
if allow_value_error: if allow_value_error:
if force_value_warning: 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/>. # along with this program. If not, see <http://www.gnu.org/licenses/>.
# ____________________________________________________________ # ____________________________________________________________
from time import time 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 def _display_classname(obj): # pragma: no cover
return(obj.__class__.__name__.lower()) 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): def setcache(self, path, index, val, self_props, props, validated):
"""add val in cache for a specified path """add val in cache for a specified path
if follower, add index if follower, add index
""" """
if 'cache' in props or 'cache' in self_props: if 'cache' in props or 'cache' in self_props:
# log.debug('setcache %s with index %s and value %s in %s (%s)', self._cache.setdefault(path, {})[index] = (val, int(time()), validated)
# path, index, val, _display_classname(self), id(self))
super().setcache(path, index, val, time(), validated) def delcache(self, path):
# log.debug('not setcache %s with index %s and value %s and props %s and %s in %s (%s)', if path in self._cache:
# path, index, val, props, self_props, _display_classname(self), id(self)) del self._cache[path]
def get_cached(self):
return self._cache
def reset_all_cache(self):
self._cache.clear()
def getcache(self, def getcache(self,
path, path,
@ -45,7 +55,12 @@ class Cache(DictCache):
type_): type_):
no_cache = False, None, False no_cache = False, None, False
if 'cache' in props or type_ == 'context_props': 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: if indexed is None:
return no_cache return no_cache
value, timestamp, validated = indexed value, timestamp, validated = indexed
@ -76,23 +91,3 @@ class Cache(DictCache):
# log.debug('getcache %s with index %s not in %s cache', # log.debug('getcache %s with index %s not in %s cache',
# path, index, _display_classname(self)) # path, index, _display_classname(self))
return no_cache 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

669
tiramisu/config.py
View file

File diff suppressed because it is too large Load diff

35
tiramisu/option/baseoption.py
View file

@ -126,29 +126,6 @@ class Base:
options.append(weakref.ref(option)) options.append(weakref.ref(option))
self._suffixes_dependencies = tuple(options) 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: def impl_is_optiondescription(self) -> bool:
return False return False
@ -189,16 +166,6 @@ class Base:
def getsubdyn(self): def getsubdyn(self):
return self._subdyn() 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 # information
def impl_get_information(self, def impl_get_information(self,
@ -287,6 +254,8 @@ class BaseOption(Base):
def impl_has_callback(self) -> bool: def impl_has_callback(self) -> bool:
"to know if a callback has been defined or not" "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 return self.impl_get_callback()[0] is not None
def _impl_get_display_name(self, def _impl_get_display_name(self,

8
tiramisu/option/choiceoption.py
View file

@ -55,10 +55,10 @@ class ChoiceOption(Option):
*args, *args,
**kwargs) **kwargs)
async def impl_get_values(self, def impl_get_values(self,
option_bag): option_bag):
if isinstance(self._choice_values, Calculation): 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): if values is not undefined and not isinstance(values, list):
raise ConfigError(_('the calculated values "{0}" for "{1}" is not a list' raise ConfigError(_('the calculated values "{0}" for "{1}" is not a list'
'').format(values, self.impl_getname())) '').format(values, self.impl_getname()))
@ -78,10 +78,10 @@ class ChoiceOption(Option):
values = self._choice_values values = self._choice_values
self.validate_values(value, values) self.validate_values(value, values)
async def validate_with_option(self, def validate_with_option(self,
value: Any, value: Any,
option_bag: OptionBag) -> None: option_bag: OptionBag) -> None:
values = await self.impl_get_values(option_bag) values = self.impl_get_values(option_bag)
self.validate_values(value, values) self.validate_values(value, values)
def validate_values(self, 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_ip = self.impl_get_extra('_allow_ip')
allow_cidr_network = self.impl_get_extra('_allow_cidr_network') allow_cidr_network = self.impl_get_extra('_allow_cidr_network')
# it's an IP so validate with IPOption # it's an IP so validate with IPOption
if allow_ip is False and allow_cidr_network is False: if allow_ip is True and allow_cidr_network is False:
raise ValueError(_('must not be an IP'))
if allow_ip is True:
try: try:
self.impl_get_extra('_ip').second_level_validation(value, warnings_only) self.impl_get_extra('_ip').second_level_validation(value, warnings_only)
return return
except ValueError as err: except ValueError as err:
if allow_cidr_network is False:
raise err raise err
if allow_cidr_network is True: if allow_cidr_network is True:
self.impl_get_extra('_network').second_level_validation(value, warnings_only) self.impl_get_extra('_network').second_level_validation(value, warnings_only)

4
tiramisu/option/dynoptiondescription.py
View file

@ -82,13 +82,13 @@ class DynOptionDescription(OptionDescription):
suffix = suffix.replace('.', '_') suffix = suffix.replace('.', '_')
return suffix return suffix
async def get_suffixes(self, def get_suffixes(self,
config_bag: ConfigBag) -> List[str]: config_bag: ConfigBag) -> List[str]:
option_bag = OptionBag() option_bag = OptionBag()
option_bag.set_option(self, option_bag.set_option(self,
None, None,
config_bag) config_bag)
values = await self._suffixes.execute(option_bag) values = self._suffixes.execute(option_bag)
if values is None: if values is None:
values = [] values = []
values_ = [] values_ = []

2
tiramisu/option/ipoption.py
View file

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

57
tiramisu/option/leadership.py
View file

@ -37,7 +37,8 @@ from ..autolib import Calculation, ParamOption
class Leadership(OptionDescription): class Leadership(OptionDescription):
__slots__ = ('leader', __slots__ = ('leader',
'followers') 'followers',
)
def __init__(self, def __init__(self,
name: str, name: str,
@ -91,14 +92,6 @@ class Leadership(OptionDescription):
child._add_dependency(self) child._add_dependency(self)
child._leadership = weakref.ref(self) child._leadership = weakref.ref(self)
if __debug__: 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(): for prop in leader.impl_getproperties():
if prop not in ALLOWED_LEADER_PROPERTIES and not isinstance(prop, Calculation): if prop not in ALLOWED_LEADER_PROPERTIES and not isinstance(prop, Calculation):
raise LeadershipError(_('leader cannot have "{}" property').format(prop)) raise LeadershipError(_('leader cannot have "{}" property').format(prop))
@ -121,7 +114,7 @@ class Leadership(OptionDescription):
opt = opt.opt opt = opt.opt
return opt in self._children[1] return opt in self._children[1]
async def reset(self, def reset(self,
values: Values, values: Values,
option_bag: OptionBag) -> None: option_bag: OptionBag) -> None:
config_bag = option_bag.config_bag.copy() config_bag = option_bag.config_bag.copy()
@ -131,10 +124,10 @@ class Leadership(OptionDescription):
soption_bag.set_option(follower, soption_bag.set_option(follower,
None, None,
config_bag) config_bag)
soption_bag.properties = await config_bag.context.cfgimpl_get_settings().getproperties(soption_bag) soption_bag.properties = config_bag.context.cfgimpl_get_settings().getproperties(soption_bag)
await values.reset(soption_bag) values.reset(soption_bag)
async def follower_force_store_value(self, def follower_force_store_value(self,
values, values,
value, value,
option_bag, option_bag,
@ -145,12 +138,12 @@ class Leadership(OptionDescription):
if value: if value:
if dyn is None: if dyn is None:
dyn = self dyn = self
for idx, follower in enumerate(await dyn.get_children(option_bag.config_bag)): for idx, follower in enumerate(dyn.get_children(option_bag.config_bag)):
foption_bag = OptionBag() foption_bag = OptionBag()
foption_bag.set_option(follower, foption_bag.set_option(follower,
None, None,
option_bag.config_bag) option_bag.config_bag)
if 'force_store_value' in await settings.getproperties(foption_bag): if 'force_store_value' in settings.getproperties(foption_bag):
if idx == 0: if idx == 0:
indexes = [None] indexes = [None]
else: else:
@ -160,15 +153,14 @@ class Leadership(OptionDescription):
foption_bag.set_option(follower, foption_bag.set_option(follower,
index, index,
option_bag.config_bag) option_bag.config_bag)
foption_bag.properties = await settings.getproperties(foption_bag) foption_bag.properties = settings.getproperties(foption_bag)
await values._p_.setvalue(foption_bag.config_bag.connection, values.set_storage_value(foption_bag.path,
foption_bag.path,
await values.getvalue(foption_bag),
owner,
index, index,
values.getvalue(foption_bag),
owner,
) )
async def pop(self, def pop(self,
values: Values, values: Values,
index: int, index: int,
option_bag: OptionBag, option_bag: OptionBag,
@ -180,28 +172,27 @@ class Leadership(OptionDescription):
config_bag.remove_validation() config_bag.remove_validation()
for follower in followers: for follower in followers:
follower_path = follower.impl_getpath() follower_path = follower.impl_getpath()
followerlen = await values._p_.get_max_length(config_bag.connection, followerlen = values.get_max_length(follower_path)
follower_path)
soption_bag = OptionBag() soption_bag = OptionBag()
soption_bag.set_option(follower, soption_bag.set_option(follower,
index, index,
config_bag) config_bag)
# do not check force_default_on_freeze or force_metaconfig_on_freeze # do not check force_default_on_freeze or force_metaconfig_on_freeze
soption_bag.properties = set() soption_bag.properties = set()
is_default = await values.is_default_owner(soption_bag, is_default = values.is_default_owner(soption_bag,
validate_meta=False) validate_meta=False)
if not is_default and followerlen > index: if not is_default and followerlen > index:
await values._p_.resetvalue_index(config_bag.connection, values.resetvalue_index(follower_path,
follower_path, index,
index) )
if followerlen > index + 1: if followerlen > index + 1:
for idx in range(index + 1, followerlen): for idx in range(index + 1, followerlen):
if await values._p_.hasvalue(config_bag.connection, if values.hasvalue(follower_path,
follower_path, idx,
idx): ):
await values._p_.reduce_index(config_bag.connection, values.reduce_index(follower_path,
follower_path, idx,
idx) )
def reset_cache(self, def reset_cache(self,
path: str, path: str,

24
tiramisu/option/option.py
View file

@ -320,7 +320,7 @@ class Option(BaseOption):
'{0}'.format(err), '{0}'.format(err),
err_index) err_index)
async def impl_validate(self, def impl_validate(self,
value: Any, value: Any,
option_bag: OptionBag, option_bag: OptionBag,
check_error: bool=True) -> None: check_error: bool=True) -> None:
@ -350,7 +350,7 @@ class Option(BaseOption):
raise ValueError(_('the value "{}" is not unique' raise ValueError(_('the value "{}" is not unique'
'').format(val)) '').format(val))
async def calculation_validator(val, def calculation_validator(val,
_index): _index):
for validator in getattr(self, '_validators', []): for validator in getattr(self, '_validators', []):
calc_is_warnings_only = hasattr(validator, 'warnings_only') and validator.warnings_only calc_is_warnings_only = hasattr(validator, 'warnings_only') and validator.warnings_only
@ -367,7 +367,7 @@ class Option(BaseOption):
soption_bag.index = _index soption_bag.index = _index
kwargs['orig_value'] = value kwargs['orig_value'] = value
await validator.execute(soption_bag, validator.execute(soption_bag,
leadership_must_have_index=True, leadership_must_have_index=True,
**kwargs) **kwargs)
except ValueWarning as warn: except ValueWarning as warn:
@ -379,7 +379,7 @@ class Option(BaseOption):
ValueWarning, ValueWarning,
self.__class__.__name__, 356) self.__class__.__name__, 356)
async def do_validation(_value, def do_validation(_value,
_index): _index):
if isinstance(_value, list): if isinstance(_value, list):
raise ValueError(_('which must not be a list').format(_value, raise ValueError(_('which must not be a list').format(_value,
@ -390,7 +390,7 @@ class Option(BaseOption):
if check_error: if check_error:
# option validation # option validation
self.validate(_value) self.validate(_value)
await self.validate_with_option(_value, self.validate_with_option(_value,
option_bag) option_bag)
if ((check_error and not is_warnings_only) or if ((check_error and not is_warnings_only) or
(not check_error and is_warnings_only)): (not check_error and is_warnings_only)):
@ -408,23 +408,23 @@ class Option(BaseOption):
self.__class__.__name__, 0) self.__class__.__name__, 0)
else: else:
raise err raise err
await calculation_validator(_value, calculation_validator(_value,
_index) _index)
try: try:
val = value val = value
err_index = force_index err_index = force_index
if not self.impl_is_multi(): if not self.impl_is_multi():
await do_validation(val, None) do_validation(val, None)
elif force_index is not None: elif force_index is not None:
if self.impl_is_submulti(): if self.impl_is_submulti():
if not isinstance(value, list): if not isinstance(value, list):
raise ValueError(_('which must be a list')) raise ValueError(_('which must be a list'))
for val in value: for val in value:
await do_validation(val, do_validation(val,
force_index) force_index)
_is_not_unique(value, option_bag) _is_not_unique(value, option_bag)
else: else:
await do_validation(val, do_validation(val,
force_index) force_index)
elif isinstance(value, Calculation) and config_bag is undefined: elif isinstance(value, Calculation) and config_bag is undefined:
pass pass
@ -438,13 +438,13 @@ class Option(BaseOption):
raise ValueError(_('which "{}" must be a list of list' raise ValueError(_('which "{}" must be a list of list'
'').format(lval)) '').format(lval))
for val in lval: for val in lval:
await do_validation(val, do_validation(val,
err_index) err_index)
_is_not_unique(lval, option_bag) _is_not_unique(lval, option_bag)
else: else:
# FIXME subtimal, not several time is whole=True! # FIXME subtimal, not several time is whole=True!
for err_index, val in enumerate(value): for err_index, val in enumerate(value):
await do_validation(val, do_validation(val,
err_index) err_index)
_is_not_unique(value, option_bag) _is_not_unique(value, option_bag)
except ValueError as err: except ValueError as err:
@ -483,7 +483,7 @@ class Option(BaseOption):
option_bag: OptionBag) -> None: option_bag: OptionBag) -> None:
pass pass
async def validate_with_option(self, def validate_with_option(self,
value: Any, value: Any,
option_bag: OptionBag) -> None: option_bag: OptionBag) -> None:
pass pass

68
tiramisu/option/optiondescription.py
View file

@ -37,7 +37,7 @@ class CacheOptionDescription(BaseOption):
def impl_already_build_caches(self) -> bool: def impl_already_build_caches(self) -> bool:
return self.impl_is_readonly() return self.impl_is_readonly()
async def _build_cache(self, def _build_cache(self,
path='', path='',
_consistencies=None, _consistencies=None,
_consistencies_id=0, _consistencies_id=0,
@ -65,14 +65,14 @@ class CacheOptionDescription(BaseOption):
# cache already set # cache already set
raise ConfigError(_('option description seems to be part of an other ' raise ConfigError(_('option description seems to be part of an other '
'config')) 'config'))
for option in await self.get_children(config_bag=undefined, for option in self.get_children(config_bag=undefined,
dyn=False): dyn=False):
if __debug__: if __debug__:
cache_option.append(option) cache_option.append(option)
sub_currpath = currpath + [option.impl_getname()] sub_currpath = currpath + [option.impl_getname()]
subpath = '.'.join(sub_currpath) subpath = '.'.join(sub_currpath)
if isinstance(option, OptionDescription): if isinstance(option, OptionDescription):
await option._build_cache(subpath, option._build_cache(subpath,
_consistencies, _consistencies,
_consistencies_id, _consistencies_id,
sub_currpath, sub_currpath,
@ -109,15 +109,15 @@ class CacheOptionDescription(BaseOption):
self._path = self._name self._path = self._name
self._set_readonly() self._set_readonly()
async def impl_build_force_store_values(self, def impl_build_force_store_values(self,
config_bag: ConfigBag, config_bag: ConfigBag,
) -> None: ) -> None:
async def do_option_bags(option): def do_option_bags(option):
if option.issubdyn(): if option.issubdyn():
dynopt = option.getsubdyn() dynopt = option.getsubdyn()
rootpath = dynopt.impl_getpath() rootpath = dynopt.impl_getpath()
subpaths = [rootpath] + option.impl_getpath()[len(rootpath) + 1:].split('.')[1:] 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) path_suffix = dynopt.convert_suffix_to_path(suffix)
subpath = '.'.join([subp + path_suffix for subp in subpaths]) subpath = '.'.join([subp + path_suffix for subp in subpaths])
doption = option.to_dynoption(subpath, doption = option.to_dynoption(subpath,
@ -142,9 +142,9 @@ class CacheOptionDescription(BaseOption):
for option in self._cache_force_store_values: for option in self._cache_force_store_values:
if option.impl_is_follower(): if option.impl_is_follower():
leader = option.impl_get_leadership().get_leader() 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() 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(): if option.issubdyn():
subpath = leader_option_bag.option.rootpath subpath = leader_option_bag.option.rootpath
doption = option.to_dynoption(subpath, doption = option.to_dynoption(subpath,
@ -155,10 +155,7 @@ class CacheOptionDescription(BaseOption):
doption = option doption = option
subpath = doption.impl_getpath() subpath = doption.impl_getpath()
for index in range(follower_len): for index in range(follower_len):
if await values._p_.hasvalue(config_bag.connection, if values.hasvalue(subpath, index):
subpath,
index,
):
continue continue
option_bag = OptionBag() option_bag = OptionBag()
option_bag.set_option(doption, option_bag.set_option(doption,
@ -166,38 +163,33 @@ class CacheOptionDescription(BaseOption):
config_bag, config_bag,
) )
option_bag.properties = frozenset() option_bag.properties = frozenset()
value = await values.getvalue(option_bag) value = values.getvalue(option_bag)
if value is None: if value is None:
continue continue
await values._p_.setvalue(config_bag.connection, values.set_storage_value(subpath,
subpath,
value,
owners.forced,
index, 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, value,
owners.forced, 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, None,
False, value,
owners.forced,
) )
class OptionDescriptionWalk(CacheOptionDescription): class OptionDescriptionWalk(CacheOptionDescription):
__slots__ = ('_children',) __slots__ = ('_children',)
async def get_child(self, def get_child(self,
name: str, name: str,
config_bag: ConfigBag, config_bag: ConfigBag,
subpath: str, subpath: str,
@ -215,7 +207,7 @@ class OptionDescriptionWalk(CacheOptionDescription):
if child.impl_is_dynoptiondescription(): if child.impl_is_dynoptiondescription():
cname = child.impl_getname() cname = child.impl_getname()
if name.startswith(cname): if name.startswith(cname):
for suffix in await child.get_suffixes(config_bag): for suffix in child.get_suffixes(config_bag):
if name == cname + child.convert_suffix_to_path(suffix): if name == cname + child.convert_suffix_to_path(suffix):
return child.to_dynoption(subpath, return child.to_dynoption(subpath,
suffix, suffix,
@ -229,7 +221,7 @@ class OptionDescriptionWalk(CacheOptionDescription):
f'in optiondescription "{self.impl_get_display_name()}"' f'in optiondescription "{self.impl_get_display_name()}"'
)) ))
async def get_children(self, def get_children(self,
config_bag: Union[ConfigBag, Undefined], config_bag: Union[ConfigBag, Undefined],
dyn: bool=True, dyn: bool=True,
) -> Union[BaseOption, SynDynOptionDescription]: ) -> Union[BaseOption, SynDynOptionDescription]:
@ -241,7 +233,7 @@ class OptionDescriptionWalk(CacheOptionDescription):
children = [] children = []
for child in self._children[1]: for child in self._children[1]:
if dyn and child.impl_is_dynoptiondescription(): 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, children.append(child.to_dynoption(subpath,
suffix, suffix,
child)) child))
@ -249,16 +241,16 @@ class OptionDescriptionWalk(CacheOptionDescription):
children.append(child) children.append(child)
return children return children
async def get_children_recursively(self, def get_children_recursively(self,
bytype: Optional[BaseOption], bytype: Optional[BaseOption],
byname: Optional[str], byname: Optional[str],
config_bag: ConfigBag, config_bag: ConfigBag,
self_opt: BaseOption=None) -> Iterator[Union[BaseOption, SynDynOptionDescription]]: self_opt: BaseOption=None) -> Iterator[Union[BaseOption, SynDynOptionDescription]]:
if self_opt is None: if self_opt is None:
self_opt = self 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(): if option.impl_is_optiondescription():
async for subopt in option.get_children_recursively(bytype, for subopt in option.get_children_recursively(bytype,
byname, byname,
config_bag): config_bag):
yield subopt yield subopt

18
tiramisu/option/syndynoptiondescription.py
View file

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

201
tiramisu/setting.py
View file

@ -18,7 +18,6 @@
from itertools import chain from itertools import chain
from .error import PropertiesOptionError, ConstError, ConfigError, LeadershipError, display_list from .error import PropertiesOptionError, ConstError, ConfigError, LeadershipError, display_list
from .i18n import _ from .i18n import _
from .asyncinit import asyncinit
"""If cache and expire is enable, time before cache is expired. """If cache and expire is enable, time before cache is expired.
@ -181,8 +180,6 @@ class OptionBag:
def copy(self): def copy(self):
option_bag = OptionBag() option_bag = OptionBag()
for key in self.__slots__: for key in self.__slots__:
if key == 'properties' and self.config_bag is undefined:
continue
if hasattr(self, key): if hasattr(self, key):
setattr(option_bag, key, getattr(self, key)) setattr(option_bag, key, getattr(self, key))
return option_bag return option_bag
@ -195,7 +192,6 @@ class ConfigBag:
'is_unrestraint', 'is_unrestraint',
'permissives', # permissives for current context 'permissives', # permissives for current context
'expiration_time', # EXPIRATION_TIME 'expiration_time', # EXPIRATION_TIME
'connection',
) )
def __init__(self, def __init__(self,
@ -239,10 +235,7 @@ class ConfigBag:
def copy(self): def copy(self):
kwargs = {} kwargs = {}
for key in self.__slots__: for key in self.__slots__:
try:
kwargs[key] = getattr(self, key) kwargs[key] = getattr(self, key)
except KeyError:
pass
return ConfigBag(**kwargs) return ConfigBag(**kwargs)
@ -363,18 +356,18 @@ undefined = Undefined()
# ____________________________________________________________ # ____________________________________________________________
class Settings(object): class Settings(object):
"``config.Config()``'s configuration options settings" "``config.Config()``'s configuration options settings"
__slots__ = ('_p_', __slots__ = ('_properties',
'_pp_', '_permissives',
'_permissives',
'__weakref__', '__weakref__',
'ro_append', 'ro_append',
'ro_remove', 'ro_remove',
'rw_append', 'rw_append',
'rw_remove', 'rw_remove',
'default_properties') 'default_properties',
)
def __init__(self, def __init__(self):
properties,
permissives):
""" """
initializer initializer
@ -382,8 +375,8 @@ class Settings(object):
:param storage: the storage type :param storage: the storage type
""" """
# generic owner # generic owner
self._p_ = properties self._properties = {}
self._pp_ = permissives self._permissives = {}
self.default_properties = DEFAULT_PROPERTIES self.default_properties = DEFAULT_PROPERTIES
self.ro_append = RO_APPEND self.ro_append = RO_APPEND
self.ro_remove = RO_REMOVE self.ro_remove = RO_REMOVE
@ -393,9 +386,9 @@ class Settings(object):
# ____________________________________________________________ # ____________________________________________________________
# get properties and permissive methods # get properties and permissive methods
async def get_context_properties(self, def get_context_properties(self,
connection, cache,
cache): ):
is_cached, props, validated = cache.getcache(None, is_cached, props, validated = cache.getcache(None,
None, None,
None, None,
@ -403,10 +396,7 @@ class Settings(object):
{}, {},
'context_props') 'context_props')
if not is_cached: if not is_cached:
props = await self._p_.getproperties(connection, props = self._properties.get(None, {}).get(None, self.default_properties)
None,
None,
self.default_properties)
cache.setcache(None, cache.setcache(None,
None, None,
props, props,
@ -415,7 +405,18 @@ class Settings(object):
True) True)
return props 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, option_bag,
apply_requires=True, apply_requires=True,
uncalculated=False, uncalculated=False,
@ -441,16 +442,14 @@ class Settings(object):
if not is_cached: if not is_cached:
props = set() props = set()
# if index, get option's properties (without index) too # if index, get option's properties (without index) too
p_props = await self._p_.getproperties(config_bag.connection, p_props = self._getproperties(path,
path,
None, None,
option.impl_getproperties()) option.impl_getproperties(),
)
if index is not None: if index is not None:
p_props = chain(p_props, p_props = chain(p_props,
await self._p_.getproperties(config_bag.connection, self._properties.get(path, {}).get(index, option.impl_getproperties())
path, )
index,
option.impl_getproperties()))
for prop in p_props: for prop in p_props:
if uncalculated or isinstance(prop, str): if uncalculated or isinstance(prop, str):
if not help_property: if not help_property:
@ -459,12 +458,12 @@ class Settings(object):
props.add((prop, prop)) props.add((prop, prop))
elif apply_requires: elif apply_requires:
if not help_property: if not help_property:
new_prop = await prop.execute(option_bag, new_prop = prop.execute(option_bag,
leadership_must_have_index=True, leadership_must_have_index=True,
for_settings=True, for_settings=True,
) )
else: else:
new_prop = await prop.help(option_bag, new_prop = prop.help(option_bag,
leadership_must_have_index=True, leadership_must_have_index=True,
for_settings=True, for_settings=True,
) )
@ -482,7 +481,7 @@ class Settings(object):
new_prop not in ALLOWED_LEADER_PROPERTIES: new_prop not in ALLOWED_LEADER_PROPERTIES:
raise LeadershipError(_('leader cannot have "{}" property').format(new_prop)) raise LeadershipError(_('leader cannot have "{}" property').format(new_prop))
props.add(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: if not uncalculated and apply_requires and not config_bag.is_unrestraint and not help_property:
cache.setcache(path, cache.setcache(path,
index, index,
@ -492,35 +491,38 @@ class Settings(object):
True) True)
return props return props
async def has_properties_index(self, def has_properties_index(self,
option_bag): option_bag):
option = option_bag.option option = option_bag.option
if option.impl_is_symlinkoption(): if option.impl_is_symlinkoption():
option = option.impl_getopt() option = option.impl_getopt()
path = option.impl_getpath() path = option.impl_getpath()
p_props = await self._p_.getproperties(option_bag.config_bag.connection, p_props = self._properties.get(path, {}).get(None, option.impl_getproperties())
path,
None,
option.impl_getproperties())
if option_bag.index is not None: if option_bag.index is not None:
p_props = chain(p_props, p_props = chain(p_props,
await self._p_.getproperties(option_bag.config_bag.connection, self._properties.get(path, {}).get(option_bag.index, option.impl_getproperties()),
path, )
option_bag.index,
option.impl_getproperties()))
for prop in p_props: for prop in p_props:
if not isinstance(prop, str) and prop.has_index(option_bag.option): if not isinstance(prop, str) and prop.has_index(option_bag.option):
return True return True
return False return False
async def get_context_permissives(self, def get_context_permissives(self):
connection): return self.getpermissives(None)
return await self.getpermissives(None,
connection=connection)
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, option_bag,
connection=None): ):
if option_bag is None: if option_bag is None:
path = None path = None
index = None index = None
@ -532,30 +534,21 @@ class Settings(object):
else: else:
path = option_bag.path path = option_bag.path
index = option_bag.index index = option_bag.index
connection = option_bag.config_bag.connection permissives = self._getpermissives(path,
permissives = await self._pp_.getpermissives(connection, None,
path, )
None)
if index is not None: if index is not None:
option_permissives = await self._pp_.getpermissives(connection, option_permissives = self._permissives.get(path, {}).get(index, set())
path,
index)
permissives = frozenset(option_permissives | permissives) permissives = frozenset(option_permissives | permissives)
return permissives return permissives
#____________________________________________________________ #____________________________________________________________
# set methods # set methods
async def set_context_properties(self, def set_context_properties(self, properties, context):
connection, self._properties.setdefault(None, {})[None] = properties
properties, context.cfgimpl_reset_cache(None)
context):
await self._p_.setproperties(connection,
None,
None,
properties)
await context.cfgimpl_reset_cache(None)
async def setproperties(self, def setproperties(self,
path, path,
properties, properties,
option_bag, option_bag,
@ -579,25 +572,22 @@ class Settings(object):
raise LeadershipError(_('a leader ({0}) cannot have ' raise LeadershipError(_('a leader ({0}) cannot have '
'"force_default_on_freeze" or "force_metaconfig_on_freeze" property without "frozen"' '"force_default_on_freeze" or "force_metaconfig_on_freeze" property without "frozen"'
'').format(opt.impl_get_display_name())) '').format(opt.impl_get_display_name()))
await self._p_.setproperties(option_bag.config_bag.connection, self._properties.setdefault(path, {})[option_bag.index] = properties
path,
option_bag.index,
properties)
# values too because of follower values could have a PropertiesOptionError has value # values too because of follower values could have a PropertiesOptionError has value
await context.cfgimpl_reset_cache(option_bag) context.cfgimpl_reset_cache(option_bag)
option_bag.properties = properties option_bag.properties = properties
async def set_context_permissives(self, def set_context_permissives(self,
connection,
permissives):
await self.setpermissives(None,
permissives, permissives,
connection=connection) ):
self.setpermissives(None,
permissives,
)
async def setpermissives(self, def setpermissives(self,
option_bag, option_bag,
permissives, permissives,
connection=None): ):
""" """
enables us to put the permissives in the storage enables us to put the permissives in the storage
@ -616,7 +606,6 @@ class Settings(object):
"").format(opt.impl_get_display_name())) "").format(opt.impl_get_display_name()))
path = option_bag.path path = option_bag.path
index = option_bag.index index = option_bag.index
connection = option_bag.config_bag.connection
else: else:
path = None path = None
index = None index = None
@ -624,17 +613,14 @@ class Settings(object):
if forbidden_permissives: if forbidden_permissives:
raise ConfigError(_('cannot add those permissives: {0}').format( raise ConfigError(_('cannot add those permissives: {0}').format(
' '.join(forbidden_permissives))) ' '.join(forbidden_permissives)))
await self._pp_.setpermissives(connection, self._permissives.setdefault(path, {})[index] = permissives
path,
index,
permissives)
if option_bag is not None: if option_bag is not None:
await option_bag.config_bag.context.cfgimpl_reset_cache(option_bag) option_bag.config_bag.context.cfgimpl_reset_cache(option_bag)
#____________________________________________________________ #____________________________________________________________
# reset methods # reset methods
async def reset(self, def reset(self,
option_bag, option_bag,
config_bag): config_bag):
if option_bag is None: if option_bag is None:
@ -648,12 +634,11 @@ class Settings(object):
"").format(opt.impl_get_display_name()) "").format(opt.impl_get_display_name())
path = option_bag.path path = option_bag.path
index = option_bag.index index = option_bag.index
await self._p_.delproperties(config_bag.connection, if path in self._properties and index in self._properties[path]:
path, del(self._properties[path][index])
index) config_bag.context.cfgimpl_reset_cache(option_bag)
await config_bag.context.cfgimpl_reset_cache(option_bag)
async def reset_permissives(self, def reset_permissives(self,
option_bag, option_bag,
config_bag): config_bag):
if option_bag is None: if option_bag is None:
@ -667,21 +652,20 @@ class Settings(object):
"").format(opt.impl_get_display_name()) "").format(opt.impl_get_display_name())
index = option_bag.index index = option_bag.index
path = option_bag.path path = option_bag.path
await self._pp_.delpermissive(config_bag.connection, if path in self._permissives and index in self._permissives[path]:
path, del(self._permissives[path][index])
index) config_bag.context.cfgimpl_reset_cache(option_bag)
await config_bag.context.cfgimpl_reset_cache(option_bag)
#____________________________________________________________ #____________________________________________________________
# validate properties # validate properties
async def calc_raises_properties(self, def calc_raises_properties(self,
option_bag, option_bag,
apply_requires=True, apply_requires=True,
uncalculated=False): uncalculated=False):
if not uncalculated and apply_requires and option_bag.properties_setted: if not uncalculated and apply_requires and option_bag.properties_setted:
option_properties = option_bag.properties option_properties = option_bag.properties
else: else:
option_properties = await self.getproperties(option_bag, option_properties = self.getproperties(option_bag,
apply_requires=apply_requires, apply_requires=apply_requires,
uncalculated=uncalculated) uncalculated=uncalculated)
return self._calc_raises_properties(option_bag.config_bag.properties, return self._calc_raises_properties(option_bag.config_bag.properties,
@ -700,17 +684,17 @@ class Settings(object):
# at this point it should not remain any property for the option # at this point it should not remain any property for the option
return properties return properties
async def validate_properties(self, def validate_properties(self,
option_bag, option_bag,
need_help=True): need_help=True):
config_properties = option_bag.config_bag.properties config_properties = option_bag.config_bag.properties
if not config_properties or config_properties == frozenset(['cache']): if not config_properties or config_properties == frozenset(['cache']):
# if no global property # if no global property
return return
properties = await self.calc_raises_properties(option_bag) properties = self.calc_raises_properties(option_bag)
if properties != frozenset(): if properties != frozenset():
if need_help: if need_help:
help_properties = dict(await self.getproperties(option_bag, help_properties = dict(self.getproperties(option_bag,
help_property=True)) help_property=True))
calc_properties = [] calc_properties = []
for property_ in self._calc_raises_properties(option_bag.config_bag.properties, for property_ in self._calc_raises_properties(option_bag.config_bag.properties,
@ -765,14 +749,11 @@ class Settings(object):
#____________________________________________________________ #____________________________________________________________
# read only/read write # read only/read write
async def _read(self, def _read(self,
remove, remove,
append, append,
config_bag): config_bag):
props = await self._p_.getproperties(config_bag.connection, props = self._properties.get(None, {}).get(None, self.default_properties)
None,
None,
self.default_properties)
modified = False modified = False
if remove & props: if remove & props:
props = props - remove props = props - remove
@ -781,20 +762,20 @@ class Settings(object):
props = props | append props = props | append
modified = True modified = True
if modified: if modified:
await self.set_context_properties(config_bag.connection, self.set_context_properties(frozenset(props),
frozenset(props), config_bag.context,
config_bag.context) )
async def read_only(self, def read_only(self,
config_bag): config_bag):
"convenience method to freeze, hide and disable" "convenience method to freeze, hide and disable"
await self._read(self.ro_remove, self._read(self.ro_remove,
self.ro_append, self.ro_append,
config_bag) config_bag)
async def read_write(self, def read_write(self,
config_bag): config_bag):
"convenience method to freeze, hide and disable" "convenience method to freeze, hide and disable"
await self._read(self.rw_remove, self._read(self.rw_remove,
self.rw_append, 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

312
tiramisu/todict.py
View file

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

438
tiramisu/value.py
View file

@ -21,46 +21,37 @@ from .error import ConfigError, PropertiesOptionError
from .setting import owners, undefined, forbidden_owners, OptionBag, ConfigBag from .setting import owners, undefined, forbidden_owners, OptionBag, ConfigBag
from .autolib import Calculation, carry_out_calculation, Params from .autolib import Calculation, carry_out_calculation, Params
from .i18n import _ from .i18n import _
from .asyncinit import asyncinit
@asyncinit
class Values: class Values:
"""The `Config`'s root is indeed in charge of the `Option()`'s 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 but the values are physicaly located here, in `Values`, wich is also
responsible of a caching utility. responsible of a caching utility.
""" """
__slots__ = ('_p_', __slots__ = ('_values',
'__weakref__') '_informations',
'__weakref__',
)
async def __init__(self, def __init__(self,
storage, default_values=None,
connection): ):
""" """
Initializes the values's dict. Initializes the values's dict.
:param storage: where values or owners are stored :param storage: where values or owners are stored
""" """
# store the storage self._informations = {}
self._p_ = storage
# set default owner # set default owner
owner = await self._p_.getowner(connection, if not default_values:
None, self._values = {None: {None: [None, owners.user]}}
None, else:
None) self._values = default_values
if owner is None:
await self._p_.setvalue(connection,
None,
None,
owners.user,
None,
new=True)
#______________________________________________________________________ #______________________________________________________________________
# get value # get value
async def get_cached_value(self, def get_cached_value(self,
option_bag: OptionBag, option_bag: OptionBag,
) -> Any: ) -> Any:
"""get value directly in cache if set """get value directly in cache if set
@ -80,15 +71,15 @@ class Values:
) )
# no cached value so get value # no cached value so get value
if not is_cached: if not is_cached:
value = await self.getvalue(option_bag) value = self.getvalue(option_bag)
# validates and warns value # validates and warns value
if not validated: if not validated:
validate = await option_bag.option.impl_validate(value, validate = option_bag.option.impl_validate(value,
option_bag, option_bag,
check_error=True, check_error=True,
) )
if 'warnings' in setting_properties: if 'warnings' in setting_properties:
await option_bag.option.impl_validate(value, option_bag.option.impl_validate(value,
option_bag, option_bag,
check_error=False, check_error=False,
) )
@ -107,37 +98,34 @@ class Values:
# and return it # and return it
return value 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 config => to metaconfig
# force_metaconfig_on_freeze in option + config is kernelconfig => 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.cfgimpl_get_settings()
if 'force_metaconfig_on_freeze' in option_bag.properties: if 'force_metaconfig_on_freeze' in option_bag.properties:
settings = option_bag.config_bag.context.cfgimpl_get_settings() settings = option_bag.config_bag.context.cfgimpl_get_settings()
if 'force_metaconfig_on_freeze' in option_bag.option.impl_getproperties() and \ if 'force_metaconfig_on_freeze' in option_bag.option.impl_getproperties() and \
not await settings._p_.getproperties(option_bag.config_bag.connection, not settings._properties.get(option_bag.path, {}).get(None, frozenset()):
option_bag.path,
None,
frozenset()):
# if force_metaconfig_on_freeze is only in option (not in config) # if force_metaconfig_on_freeze is only in option (not in config)
return option_bag.config_bag.context.impl_type == 'config' return option_bag.config_bag.context.impl_type == 'config'
else: else:
return True return True
return False return False
async def _do_value_list(self, def _do_value_list(self,
value: Any, value: Any,
option_bag: OptionBag): option_bag: OptionBag):
ret = [] ret = []
for val in value: for val in value:
if isinstance(val, (list, tuple)): 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): elif isinstance(val, Calculation):
ret.append(await val.execute(option_bag)) ret.append(val.execute(option_bag))
else: else:
ret.append(val) ret.append(val)
return ret return ret
async def getvalue(self, def getvalue(self,
option_bag, option_bag,
): ):
"""actually retrieves the value """actually retrieves the value
@ -156,37 +144,32 @@ class Values:
_index = None _index = None
else: else:
_index = index _index = index
owner, value = await self._p_.getowner(option_bag.config_bag.connection, value, owner = self._values.get(option_bag.path, {}).get(_index, [undefined, owners.default])
option_bag.path,
owners.default,
index=_index,
with_value=True,
)
if owner == owners.default or \ if owner == owners.default or \
('frozen' in option_bag.properties and \ ('frozen' in option_bag.properties and \
('force_default_on_freeze' in option_bag.properties or await self.force_to_metaconfig(option_bag))): ('force_default_on_freeze' in option_bag.properties or self.force_to_metaconfig(option_bag))):
value = await self.getdefaultvalue(option_bag) value = self.getdefaultvalue(option_bag)
else: else:
value = await self.calc_value(option_bag, value) value = self.calc_value(option_bag, value)
return value return value
async def calc_value(self, def calc_value(self,
option_bag, option_bag,
value, value,
reset_cache=True): reset_cache=True):
if isinstance(value, Calculation): if isinstance(value, Calculation):
try: try:
value = await value.execute(option_bag) value = value.execute(option_bag)
except ConfigError as err: except ConfigError as err:
msg = _(f'error when calculating "{option_bag.option.impl_get_display_name()}": {err} : {option_bag.path}') msg = _(f'error when calculating "{option_bag.option.impl_get_display_name()}": {err} : {option_bag.path}')
raise ConfigError(msg) from err raise ConfigError(msg) from err
elif isinstance(value, (list, tuple)): 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: if reset_cache:
await self.calculate_reset_cache(option_bag, value) self.calculate_reset_cache(option_bag, value)
return value return value
async def getdefaultvalue(self, def getdefaultvalue(self,
option_bag, option_bag,
): ):
"""get default value: """get default value:
@ -194,19 +177,13 @@ class Values:
- get calculated value or - get calculated value or
- get default value - 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: if moption_bag is not None:
# retrieved value from parent config # retrieved value from parent config
return await moption_bag.config_bag.context.cfgimpl_get_values().get_cached_value(moption_bag) return 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
# now try to get default value: # now try to get default value:
value = await self.calc_value(option_bag, value = self.calc_value(option_bag,
option_bag.option.impl_getdefault(), option_bag.option.impl_getdefault(),
) )
if option_bag.index is not None and isinstance(value, (list, tuple)): if option_bag.index is not None and isinstance(value, (list, tuple)):
@ -219,7 +196,7 @@ class Values:
else: else:
# no value for this index, retrieve default multi value # no value for this index, retrieve default multi value
# default_multi is already a list for submulti # 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()) option_bag.option.impl_getdefault_multi())
elif option_bag.option.impl_is_multi(): elif option_bag.option.impl_is_multi():
# if index, must return good value for this index # if index, must return good value for this index
@ -228,11 +205,11 @@ class Values:
else: else:
# no value for this index, retrieve default multi value # no value for this index, retrieve default multi value
# default_multi is already a list for submulti # 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()) option_bag.option.impl_getdefault_multi())
return value return value
async def calculate_reset_cache(self, def calculate_reset_cache(self,
option_bag, option_bag,
value): value):
if not 'expire' in option_bag.properties: if not 'expire' in option_bag.properties:
@ -249,60 +226,10 @@ class Values:
# so do not invalidate cache # so do not invalidate cache
return return
# calculated value is a new value, so reset cache # 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.cfgimpl_reset_cache(option_bag)
# and manage force_store_value # 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, def isempty(self,
opt, opt,
value, value,
@ -319,21 +246,23 @@ class Values:
#______________________________________________________________________ #______________________________________________________________________
# set value # set value
async def setvalue(self, def setvalue(self,
value, value,
option_bag): option_bag,
):
context = option_bag.config_bag.context 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: if 'validator' in option_bag.config_bag.properties:
await self.setvalue_validation(value, self.setvalue_validation(value,
option_bag) option_bag)
if isinstance(value, list): if isinstance(value, list):
# copy # copy
value = value.copy() value = value.copy()
await self._setvalue(option_bag, self._setvalue(option_bag,
value, value,
owner) owner,
)
setting_properties = option_bag.config_bag.properties setting_properties = option_bag.config_bag.properties
validator = 'validator' in setting_properties and 'demoting_error_warning' not in setting_properties validator = 'validator' in setting_properties and 'demoting_error_warning' not in setting_properties
if validator: if validator:
@ -345,46 +274,59 @@ class Values:
setting_properties, setting_properties,
validator) validator)
if 'force_store_value' in setting_properties and option_bag.option.impl_is_leader(): 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, value,
option_bag, option_bag,
owners.forced, owners.forced,
) )
async def setvalue_validation(self, def setvalue_validation(self,
value, value,
option_bag): option_bag):
settings = option_bag.config_bag.context.cfgimpl_get_settings() settings = option_bag.config_bag.context.cfgimpl_get_settings()
# First validate properties with this value # First validate properties with this value
opt = option_bag.option opt = option_bag.option
settings.validate_frozen(option_bag) 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, settings.validate_mandatory(val,
option_bag) option_bag)
# Value must be valid for option # Value must be valid for option
await opt.impl_validate(val, opt.impl_validate(val,
option_bag, option_bag,
check_error=True) check_error=True)
if 'warnings' in option_bag.config_bag.properties: if 'warnings' in option_bag.config_bag.properties:
# No error found so emit warnings # No error found so emit warnings
await opt.impl_validate(value, opt.impl_validate(value,
option_bag, option_bag,
check_error=False) check_error=False)
async def _setvalue(self, def _setvalue(self,
option_bag: OptionBag, option_bag: OptionBag,
value: Any, value: Any,
owner: str, owner: str,
) -> None: ) -> None:
await option_bag.config_bag.context.cfgimpl_reset_cache(option_bag) option_bag.config_bag.context.cfgimpl_reset_cache(option_bag)
await self._p_.setvalue(option_bag.config_bag.connection, self.set_storage_value(option_bag.path,
option_bag.path, option_bag.index,
value, value,
owner, 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, option_bag: OptionBag,
) -> None: ) -> None:
if 'force_store_value' not in option_bag.config_bag.properties: if 'force_store_value' not in option_bag.config_bag.properties:
@ -392,7 +334,7 @@ class Values:
for woption in option_bag.option._get_suffixes_dependencies(): for woption in option_bag.option._get_suffixes_dependencies():
option = woption() option = woption()
force_store_options = [] force_store_options = []
async for coption in option.get_children_recursively(None, for coption in option.get_children_recursively(None,
None, None,
option_bag.config_bag, option_bag.config_bag,
): ):
@ -402,7 +344,7 @@ class Values:
continue continue
rootpath = option.impl_getpath() rootpath = option.impl_getpath()
settings = option_bag.config_bag.context.cfgimpl_get_settings() settings = option_bag.config_bag.context.cfgimpl_get_settings()
for suffix in await option.get_suffixes(option_bag.config_bag): for suffix in option.get_suffixes(option_bag.config_bag):
for coption in force_store_options: for coption in force_store_options:
subpaths = [rootpath] + coption.impl_getpath()[len(rootpath) + 1:].split('.')[:-1] subpaths = [rootpath] + coption.impl_getpath()[len(rootpath) + 1:].split('.')[:-1]
path_suffix = option.convert_suffix_to_path(suffix) path_suffix = option.convert_suffix_to_path(suffix)
@ -419,7 +361,7 @@ class Values:
option_bag.config_bag, option_bag.config_bag,
) )
loption_bag.properties = frozenset() loption_bag.properties = frozenset()
indexes = range(len(await self.getvalue(loption_bag))) indexes = range(len(self.getvalue(loption_bag)))
else: else:
indexes = [None] indexes = [None]
for index in indexes: for index in indexes:
@ -428,16 +370,10 @@ class Values:
index, index,
option_bag.config_bag, option_bag.config_bag,
) )
coption_bag.properties = await settings.getproperties(coption_bag) coption_bag.properties = settings.getproperties(coption_bag)
await self._p_.setvalue(coption_bag.config_bag.connection, self._values.setdefault(coption_bag.path, {})[index] = [self.getvalue(coption_bag), owners.forced]
coption_bag.path,
await self.getvalue(coption_bag),
owners.forced,
index,
False,
)
async def _get_modified_parent(self, def _get_modified_parent(self,
option_bag: OptionBag) -> Optional[OptionBag]: option_bag: OptionBag) -> Optional[OptionBag]:
""" Search in differents parents a Config with a modified value """ Search in differents parents a Config with a modified value
If not found, return None If not found, return None
@ -457,12 +393,12 @@ class Values:
# remove force_metaconfig_on_freeze only if option in metaconfig # remove force_metaconfig_on_freeze only if option in metaconfig
# hasn't force_metaconfig_on_freeze properties # hasn't force_metaconfig_on_freeze properties
ori_properties = doption_bag.properties ori_properties = doption_bag.properties
doption_bag.properties = await doption_bag.config_bag.context.cfgimpl_get_settings().getproperties(doption_bag) doption_bag.properties = doption_bag.config_bag.context.cfgimpl_get_settings().getproperties(doption_bag)
if not await self.force_to_metaconfig(doption_bag): if not self.force_to_metaconfig(doption_bag):
doption_bag.properties = ori_properties - {'force_metaconfig_on_freeze'} doption_bag.properties = ori_properties - {'force_metaconfig_on_freeze'}
else: else:
doption_bag.properties = ori_properties doption_bag.properties = ori_properties
parent_owner = await parent.cfgimpl_get_values().getowner(doption_bag, parent_owner = parent.cfgimpl_get_values().getowner(doption_bag,
only_default=True) only_default=True)
if parent_owner != owners.default: if parent_owner != owners.default:
return doption_bag return doption_bag
@ -473,14 +409,28 @@ class Values:
#______________________________________________________________________ #______________________________________________________________________
# owner # owner
async def is_default_owner(self, def is_default_owner(self,
option_bag, option_bag,
validate_meta=True): validate_meta=True):
return await self.getowner(option_bag, return self.getowner(option_bag,
validate_meta=validate_meta, validate_meta=validate_meta,
only_default=True) == owners.default 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, option_bag,
validate_meta=True, validate_meta=True,
only_default=False): only_default=False):
@ -500,35 +450,32 @@ class Values:
option_bag.option = opt option_bag.option = opt
option_bag.path = opt.impl_getpath() option_bag.path = opt.impl_getpath()
settings = context.cfgimpl_get_settings() settings = context.cfgimpl_get_settings()
await settings.validate_properties(option_bag) settings.validate_properties(option_bag)
if 'frozen' in option_bag.properties and \ if 'frozen' in option_bag.properties and \
'force_default_on_freeze' in option_bag.properties: 'force_default_on_freeze' in option_bag.properties:
return owners.default return owners.default
if only_default: if only_default:
if await self._p_.hasvalue(option_bag.config_bag.connection, if self.hasvalue(option_bag.path,
option_bag.path,
option_bag.index): option_bag.index):
owner = 'not_default' owner = 'not_default'
else: else:
owner = owners.default owner = owners.default
else: else:
owner = await self._p_.getowner(option_bag.config_bag.connection, owner = self._values.get(option_bag.path, {}).get(option_bag.index, [undefined, owners.default])[1]
option_bag.path,
owners.default,
index=option_bag.index)
if validate_meta is not False and (owner is owners.default or \ 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): '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: 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.cfgimpl_get_values().getowner(moption_bag,
only_default=only_default) only_default=only_default)
elif 'force_metaconfig_on_freeze' in option_bag.properties: elif 'force_metaconfig_on_freeze' in option_bag.properties:
return owners.default return owners.default
return owner return owner
async def setowner(self, def setowner(self,
owner, owner,
option_bag): option_bag,
):
""" """
sets a owner to an option sets a owner to an option
@ -542,99 +489,108 @@ class Values:
if owner in forbidden_owners: if owner in forbidden_owners:
raise ValueError(_('set owner "{0}" is forbidden').format(str(owner))) raise ValueError(_('set owner "{0}" is forbidden').format(str(owner)))
if not await self._p_.hasvalue(option_bag.config_bag.connection, if not self.hasvalue(option_bag.path, option_bag.index):
option_bag.path):
raise ConfigError(_('no value for {0} cannot change owner to {1}' raise ConfigError(_('no value for {0} cannot change owner to {1}'
'').format(option_bag.path, owner)) '').format(option_bag.path, owner))
option_bag.config_bag.context.cfgimpl_get_settings().validate_frozen(option_bag) option_bag.config_bag.context.cfgimpl_get_settings().validate_frozen(option_bag)
await self._p_.setowner(option_bag.config_bag.connection, self._values[option_bag.path][option_bag.index][1] = owner
option_bag.path,
owner,
index=option_bag.index)
#______________________________________________________________________ #______________________________________________________________________
# reset # reset
async def reset(self, def reset(self,
option_bag): option_bag):
context = option_bag.config_bag.context context = option_bag.config_bag.context
hasvalue = await self._p_.hasvalue(option_bag.config_bag.connection, hasvalue = self.hasvalue(option_bag.path)
option_bag.path)
setting_properties = option_bag.config_bag.properties setting_properties = option_bag.config_bag.properties
if hasvalue and 'validator' in 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 = option_bag.config_bag.copy()
config_bag.remove_validation() config_bag.remove_validation()
config_bag.context = fake_context config_bag.context = fake_context
soption_bag = option_bag.copy() soption_bag = option_bag.copy()
soption_bag.config_bag = config_bag soption_bag.config_bag = config_bag
fake_value = fake_context.cfgimpl_get_values() fake_value = fake_context.cfgimpl_get_values()
await fake_value.reset(soption_bag) fake_value.reset(soption_bag)
soption_bag.config_bag.properties = option_bag.config_bag.properties soption_bag.config_bag.properties = option_bag.config_bag.properties
value = await fake_value.getdefaultvalue(soption_bag) value = fake_value.getdefaultvalue(soption_bag)
await fake_value.setvalue_validation(value, fake_value.setvalue_validation(value,
soption_bag) soption_bag)
opt = option_bag.option opt = option_bag.option
if opt.impl_is_leader(): if opt.impl_is_leader():
await opt.impl_get_leadership().reset(self, opt.impl_get_leadership().reset(self,
option_bag) option_bag)
if hasvalue: if hasvalue:
if 'force_store_value' in option_bag.config_bag.properties and 'force_store_value' in option_bag.properties: 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, value,
owners.forced) owners.forced,
)
else: else:
# for leader only # for leader only
value = None value = None
await self._p_.resetvalue(option_bag.config_bag.connection, if option_bag.path in self._values:
option_bag.path) del self._values[option_bag.path]
await context.cfgimpl_reset_cache(option_bag) context.cfgimpl_reset_cache(option_bag)
if 'force_store_value' in setting_properties and option_bag.option.impl_is_leader(): if 'force_store_value' in setting_properties and option_bag.option.impl_is_leader():
if value is None: if value is None:
value = await self.getdefaultvalue(option_bag) value = self.getdefaultvalue(option_bag)
await option_bag.option.impl_get_leadership().follower_force_store_value(self, option_bag.option.impl_get_leadership().follower_force_store_value(self,
value, value,
option_bag, option_bag,
owners.forced) 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): option_bag):
if await self._p_.hasvalue(option_bag.config_bag.connection, if self.hasvalue(option_bag.path,
option_bag.path,
index=option_bag.index): index=option_bag.index):
context = option_bag.config_bag.context context = option_bag.config_bag.context
setting_properties = option_bag.config_bag.properties setting_properties = option_bag.config_bag.properties
if 'validator' in setting_properties: if 'validator' in setting_properties:
fake_context = await context._gen_fake_values(option_bag.config_bag.connection) fake_context = context._gen_fake_values()
fake_value = fake_context.cfgimpl_get_values() fake_value = fake_context.cfgimpl_get_values()
config_bag = option_bag.config_bag.copy() config_bag = option_bag.config_bag.copy()
config_bag.remove_validation() config_bag.remove_validation()
config_bag.context = fake_context config_bag.context = fake_context
soption_bag = option_bag.copy() soption_bag = option_bag.copy()
soption_bag.config_bag = config_bag soption_bag.config_bag = config_bag
await fake_value.reset_follower(soption_bag) fake_value.reset_follower(soption_bag)
value = await fake_value.getdefaultvalue(soption_bag) value = fake_value.getdefaultvalue(soption_bag)
await fake_value.setvalue_validation(value, fake_value.setvalue_validation(value,
soption_bag) soption_bag)
if 'force_store_value' in setting_properties and 'force_store_value' in option_bag.properties: 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, value,
owners.forced) owners.forced,
)
else: else:
await self._p_.resetvalue_index(option_bag.config_bag.connection, self.resetvalue_index(option_bag.path,
option_bag.path, option_bag.index,
option_bag.index) )
await context.cfgimpl_reset_cache(option_bag) context.cfgimpl_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, index,
option_bag, option_bag,
subconfig): subconfig):
current_value = await self.get_cached_value(option_bag) current_value = self.get_cached_value(option_bag)
length = len(current_value) length = len(current_value)
if index >= length: if index >= length:
raise IndexError(_('index {} is greater than the length {} ' raise IndexError(_('index {} is greater than the length {} '
@ -642,16 +598,17 @@ class Values:
length, length,
option_bag.option.impl_get_display_name())) option_bag.option.impl_get_display_name()))
current_value.pop(index) current_value.pop(index)
await subconfig.cfgimpl_get_description().pop(self, subconfig.cfgimpl_get_description().pop(self,
index, index,
option_bag) option_bag)
await self.setvalue(current_value, self.setvalue(current_value,
option_bag) option_bag,
)
#______________________________________________________________________ #______________________________________________________________________
# information # information
async def set_information(self, def set_information(self,
config_bag, config_bag,
option_bag, option_bag,
key, key,
@ -666,15 +623,12 @@ class Values:
path = None path = None
else: else:
path = option_bag.path path = option_bag.path
await self._p_.set_information(config_bag.connection, self._informations.setdefault(path, {})[key] = value
path,
key,
value)
if path is not None: if path is not None:
for option in option_bag.option.get_dependencies_information(itself=True): for option in option_bag.option.get_dependencies_information(itself=True):
await config_bag.context.cfgimpl_reset_cache(option_bag) config_bag.context.cfgimpl_reset_cache(option_bag)
async def get_information(self, def get_information(self,
config_bag, config_bag,
option_bag, option_bag,
key, key,
@ -689,10 +643,7 @@ class Values:
else: else:
path = option_bag.path path = option_bag.path
try: try:
return await self._p_.get_information(config_bag.connection, return self._informations[path][key]
path,
key,
)
except KeyError as err: except KeyError as err:
if option_bag: if option_bag:
return option_bag.option.impl_get_information(key, default) return option_bag.option.impl_get_information(key, default)
@ -700,25 +651,24 @@ class Values:
return default return default
raise ValueError(_("information's item not found: {0}").format(key)) raise ValueError(_("information's item not found: {0}").format(key))
async def del_information(self, def del_information(self,
connection,
key, key,
raises=True, raises=True,
path=None): path=None,
await self._p_.del_information(connection, ):
path, if path in self._informations and key in self._informations[path]:
key, del self._informations[path][key]
raises) elif raises:
raise ValueError(_(f"information's item not found \"{key}\""))
async def list_information(self, def list_information(self,
connection, path=None,
path=None): ):
return await self._p_.list_information(connection, return list(self._informations.get(path, {}).keys())
path)
#______________________________________________________________________ #______________________________________________________________________
# mandatory warnings # mandatory warnings
async def _mandatory_warnings(self, def _mandatory_warnings(self,
context, context,
config_bag, config_bag,
description, description,
@ -726,7 +676,7 @@ class Values:
subconfig, subconfig,
od_config_bag): od_config_bag):
settings = context.cfgimpl_get_settings() settings = context.cfgimpl_get_settings()
for option in await description.get_children(config_bag): for option in description.get_children(config_bag):
name = option.impl_getname() name = option.impl_getname()
if option.impl_is_optiondescription(): if option.impl_is_optiondescription():
try: try:
@ -734,13 +684,13 @@ class Values:
option_bag.set_option(option, option_bag.set_option(option,
None, None,
od_config_bag) od_config_bag)
option_bag.properties = await settings.getproperties(option_bag) option_bag.properties = settings.getproperties(option_bag)
subsubconfig = await subconfig.get_subconfig(option_bag) subsubconfig = subconfig.get_subconfig(option_bag)
except PropertiesOptionError as err: except PropertiesOptionError as err:
pass pass
else: else:
async for option in self._mandatory_warnings(context, for option in self._mandatory_warnings(context,
config_bag, config_bag,
option, option,
currpath + [name], currpath + [name],
@ -755,9 +705,9 @@ class Values:
option_bag.set_option(option, option_bag.set_option(option,
None, None,
config_bag) config_bag)
option_bag.properties = await settings.getproperties(option_bag) option_bag.properties = settings.getproperties(option_bag)
if 'mandatory' in option_bag.properties or 'empty' in option_bag.properties: if 'mandatory' in option_bag.properties or 'empty' in option_bag.properties:
await subconfig.getattr(name, subconfig.getattr(name,
option_bag) option_bag)
else: else:
for index in range(subconfig.cfgimpl_get_length()): for index in range(subconfig.cfgimpl_get_length()):
@ -765,9 +715,9 @@ class Values:
option_bag.set_option(option, option_bag.set_option(option,
index, index,
config_bag) config_bag)
option_bag.properties = await settings.getproperties(option_bag) option_bag.properties = settings.getproperties(option_bag)
if 'mandatory' in option_bag.properties or 'empty' in option_bag.properties: if 'mandatory' in option_bag.properties or 'empty' in option_bag.properties:
await subconfig.getattr(name, subconfig.getattr(name,
option_bag) option_bag)
except PropertiesOptionError as err: except PropertiesOptionError as err:
if err.proptype in (['mandatory'], ['empty']): if err.proptype in (['mandatory'], ['empty']):
@ -775,7 +725,7 @@ class Values:
except ConfigError: except ConfigError:
pass pass
async def mandatory_warnings(self, def mandatory_warnings(self,
config_bag): config_bag):
"""convenience function to trace Options that are mandatory and """convenience function to trace Options that are mandatory and
where no value has been set where no value has been set
@ -790,16 +740,14 @@ class Values:
nconfig_bag = ConfigBag(context=config_bag.context, nconfig_bag = ConfigBag(context=config_bag.context,
properties=frozenset(setting_properties), properties=frozenset(setting_properties),
permissives=config_bag.permissives) permissives=config_bag.permissives)
nconfig_bag.connection = config_bag.connection
nconfig_bag.set_permissive() nconfig_bag.set_permissive()
od_config_bag = ConfigBag(context=nconfig_bag.context, od_config_bag = ConfigBag(context=nconfig_bag.context,
properties=frozenset(od_setting_properties), properties=frozenset(od_setting_properties),
permissives=nconfig_bag.permissives) permissives=nconfig_bag.permissives)
od_config_bag.connection = config_bag.connection
od_config_bag.set_permissive() od_config_bag.set_permissive()
descr = context.cfgimpl_get_description() descr = context.cfgimpl_get_description()
async for option in self._mandatory_warnings(context, for option in self._mandatory_warnings(context,
nconfig_bag, nconfig_bag,
descr, descr,
[], [],
@ -809,21 +757,11 @@ class Values:
#____________________________________________________________ #____________________________________________________________
# default owner methods # default owner methods
async def set_context_owner(self, def set_context_owner(self, owner):
connection,
owner):
":param owner: sets the default value for owner at the Config level" ":param owner: sets the default value for owner at the Config level"
if owner in forbidden_owners: if owner in forbidden_owners:
raise ValueError(_('set owner "{0}" is forbidden').format(str(owner))) raise ValueError(_('set owner "{0}" is forbidden').format(str(owner)))
self._values[None][None][1] = owner
await self._p_.setowner(connection, def get_context_owner(self):
None, return self._values[None][None][1]
owner,
index=None)
async def get_context_owner(self,
connection):
return await self._p_.getowner(connection,
None,
None,
None)