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

Compare commits

base: stove:1a5e4e37d129459fd3f5180ec7924c05e2bfa7e8
Branches Tags
stove:main
stove:develop
stove:choices
stove:feature/5.0
stove:dynamic_family
stove:feature/4.0
stove:5.2.0
stove:5.2.0rc0
stove:5.2.0a36
stove:5.2.0a35
stove:5.2.0a34
stove:5.2.0a33
stove:4.2.0a0
stove:5.2.0a32
stove:5.2.0a31
stove:5.2.0a30
stove:5.2.0a29
stove:5.2.0a28
stove:5.2.0a27
stove:5.2.0a26
stove:5.2.0a25
stove:5.2.0a24
stove:5.2.0a23
stove:5.2.0a22
stove:5.2.0a21
stove:5.2.0a20
stove:5.2.0a19
stove:5.2.0a18
stove:5.2.0a17
stove:5.2.0a16
stove:5.2.0a15
stove:5.2.0a14
stove:5.2.0a13
stove:5.2.0a12
stove:5.2.0a11
stove:5.2.0a10
stove:5.2.0a9
stove:5.2.0a8
stove:5.2.0a7
stove:5.2.0a6
stove:5.2.0a5
stove:5.2.0a4
stove:5.2.0a3
stove:5.2.0a2
stove:5.2.0a1
stove:5.2.0a0
stove:5.1.1a1
stove:5.1.1a0
stove:5.1.0
stove:5.1.0rc0
stove:5.0.0
stove:5.0.0rc0
stove:4.0.2
stove:4.0.1
..
compare: stove:30dea5447084f5cd5b0cb0314f411acb5771199a
Branches Tags
stove:develop
stove:main
stove:choices
stove:feature/5.0
stove:dynamic_family
stove:feature/4.0
stove:5.2.0
stove:5.2.0rc0
stove:5.2.0a36
stove:5.2.0a35
stove:5.2.0a34
stove:5.2.0a33
stove:4.2.0a0
stove:5.2.0a32
stove:5.2.0a31
stove:5.2.0a30
stove:5.2.0a29
stove:5.2.0a28
stove:5.2.0a27
stove:5.2.0a26
stove:5.2.0a25
stove:5.2.0a24
stove:5.2.0a23
stove:5.2.0a22
stove:5.2.0a21
stove:5.2.0a20
stove:5.2.0a19
stove:5.2.0a18
stove:5.2.0a17
stove:5.2.0a16
stove:5.2.0a15
stove:5.2.0a14
stove:5.2.0a13
stove:5.2.0a12
stove:5.2.0a11
stove:5.2.0a10
stove:5.2.0a9
stove:5.2.0a8
stove:5.2.0a7
stove:5.2.0a6
stove:5.2.0a5
stove:5.2.0a4
stove:5.2.0a3
stove:5.2.0a2
stove:5.2.0a1
stove:5.2.0a0
stove:5.1.1a1
stove:5.1.1a0
stove:5.1.0
stove:5.1.0rc0
stove:5.0.0
stove:5.0.0rc0
stove:4.0.2
stove:4.0.1

No commits in common. "1a5e4e37d129459fd3f5180ec7924c05e2bfa7e8" and "30dea5447084f5cd5b0cb0314f411acb5771199a" have entirely different histories.
1a5e4e37d1 ... 30dea54470

129 changed files with 20970 additions and 17968 deletions
Show stats Expand all files Collapse all files

2
AUTHORS
View file

@ -1,7 +1,7 @@
Authors
--------
Emmanuel Garette <egarette@silique.fr> lead developer
Emmanuel Garette <egarette@cadoles.com> lead developer
Gwenaël Rémond <gremond@cadoles.com> developer
Daniel Dehennin <daniel.dehennin@ac-dijon.fr> contributor

493
tests/auto/test_auto.py
View file

@ -11,7 +11,7 @@ do_autopath()
from tiramisu import Config, MetaConfig, \
StrOption, SymLinkOption, OptionDescription, Leadership, DynOptionDescription, \
submulti, undefined, owners, Params, ParamOption, Calculation
from tiramisu.error import PropertiesOptionError, ConfigError, LeadershipError
from tiramisu.error import PropertiesOptionError, APIError, ConfigError, LeadershipError
ICON = u'\u2937'
OPTIONS_TYPE = {'str': {'type': str,
@ -74,9 +74,9 @@ def _autocheck_default_value(cfg, path, conf, **kwargs):
"""set and get values
"""
# check if is a multi, a leader or a follower
multi = cfg.unrestraint.option(path).ismulti()
submulti_ = cfg.unrestraint.option(path).issubmulti()
isfollower = cfg.unrestraint.option(path).isfollower()
multi = cfg.unrestraint.option(path).option.ismulti()
submulti_ = cfg.unrestraint.option(path).option.issubmulti()
isfollower = cfg.unrestraint.option(path).option.isfollower()
# set default value (different if value is multi or not)
empty_value = kwargs['default']
@ -93,14 +93,11 @@ def _autocheck_default_value(cfg, path, conf, **kwargs):
assert cfg_.option(path).value.get() == empty_value
assert cfg_.forcepermissive.option(path).value.get() == empty_value
elif not kwargs.get('propertyerror', False):
with raises(PropertiesOptionError):
cfg_.option(path).value.get()
raises(PropertiesOptionError, "cfg_.option(path).value.get()")
assert cfg_.forcepermissive.option(path).value.get() == empty_value
else:
with raises(PropertiesOptionError):
cfg_.option(path).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(path).value.get()
raises(PropertiesOptionError, "cfg_.option(path).value.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(path).value.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(path, 0).value.get() == empty_value
@ -108,23 +105,20 @@ def _autocheck_default_value(cfg, path, conf, **kwargs):
assert cfg_.forcepermissive.option(path, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(path, 1).value.get() == empty_value
elif not kwargs.get('propertyerror', False):
with raises(PropertiesOptionError):
cfg_.option(path, 0).value.get()
raises(PropertiesOptionError, "cfg_.option(path, 0).value.get()")
assert cfg_.forcepermissive.option(path, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(path, 1).value.get() == empty_value
else:
with raises(PropertiesOptionError):
cfg_.option(path, 0).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(path, 0).value.get()
raises(PropertiesOptionError, "cfg_.option(path, 0).value.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(path, 0).value.get()")
def _set_value(cfg, pathwrite, conf, **kwargs):
set_permissive = kwargs.get('set_permissive', True)
multi = cfg.unrestraint.option(pathwrite).ismulti()
submulti_ = cfg.unrestraint.option(pathwrite).issubmulti()
isleader = cfg.unrestraint.option(pathwrite).isleader()
isfollower = cfg.unrestraint.option(pathwrite).isfollower()
multi = cfg.unrestraint.option(pathwrite).option.ismulti()
submulti_ = cfg.unrestraint.option(pathwrite).option.issubmulti()
isleader = cfg.unrestraint.option(pathwrite).option.isleader()
isfollower = cfg.unrestraint.option(pathwrite).option.isfollower()
if not multi:
first_value = FIRST_VALUE
elif submulti_ is False:
@ -148,25 +142,20 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
with warnings.catch_warnings(record=True) as w:
if isleader:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
with raises(ConfigError):
cfg_.option(pathwrite, 0).value.set(first_value[0])
raises(APIError, "cfg_.option(pathwrite, 0).value.set(first_value[0])")
if not set_permissive:
cfg_.option(pathwrite).value.set([first_value[0]])
else:
cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])
elif not kwargs.get('propertyerror', False):
with raises(PropertiesOptionError):
cfg_.option(pathwrite).value.set([first_value[0]])
raises(PropertiesOptionError, "cfg_.option(pathwrite).value.set([first_value[0]])")
if set_permissive:
cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])
else:
with raises(PropertiesOptionError):
cfg_.option(pathwrite).value.set([first_value[0]])
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])
raises(PropertiesOptionError, "cfg_.option(pathwrite).value.set([first_value[0]])")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathwrite).value.set([first_value[0]])")
if len(first_value) > 1:
with raises(ConfigError):
cfg_.unrestraint.option(pathwrite).value.set(first_value[1])
raises(APIError, "cfg_.unrestraint.option(pathwrite).value.set(first_value[1])")
elif isfollower:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not set_permissive:
@ -174,17 +163,13 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
else:
cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)
elif not kwargs.get('propertyerror', False):
with raises(PropertiesOptionError):
cfg_.option(pathwrite, 1).value.set(second_value)
raises(PropertiesOptionError, "cfg_.option(pathwrite, 1).value.set(second_value)")
if set_permissive:
cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)
else:
with raises(PropertiesOptionError):
cfg_.option(pathwrite, 1).value.set(second_value)
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)
with raises(ConfigError):
cfg_.unrestraint.option(pathwrite).value.set([second_value, second_value])
raises(PropertiesOptionError, "cfg_.option(pathwrite, 1).value.set(second_value)")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathwrite, 1).value.set(second_value)")
raises(APIError, "cfg_.unrestraint.option(pathwrite).value.set([second_value, second_value])")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
@ -193,16 +178,13 @@ def _set_value(cfg, pathwrite, conf, **kwargs):
else:
cfg_.forcepermissive.option(pathwrite).value.set(first_value)
elif not kwargs.get('propertyerror', False):
with raises(PropertiesOptionError):
cfg_.option(pathwrite).value.set(first_value)
raises(PropertiesOptionError, "cfg_.option(pathwrite).value.set(first_value)")
if set_permissive:
cfg_.forcepermissive.option(pathwrite).value.set(first_value)
else:
with raises(PropertiesOptionError):
cfg_.option(pathwrite).value.set(first_value)
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathwrite).value.set(first_value)
#FIXME raises(ConfigError, "cfg_.unrestraint.option(pathwrite).value.set(first_value)")
raises(PropertiesOptionError, "cfg_.option(pathwrite).value.set(first_value)")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathwrite).value.set(first_value)")
#FIXME raises(APIError, "cfg_.unrestraint.option(pathwrite).value.set(first_value)")
def _getproperties(multi, isfollower, kwargs):
@ -226,15 +208,13 @@ def _check_properties(cfg, mcfg, pathread, conf, kwargs, props_permissive, props
cfg_ = cfg.config(conf)
else:
cfg_ = cfg
if not cfg.unrestraint.option(pathread).isfollower():
if not cfg.unrestraint.option(pathread).option.isfollower():
if not kwargs.get('permissive_od', False):
assert set(cfg_.option(pathread).property.get()) == set(props_permissive)
assert set(cfg_.option(pathread).property.get()) == set(props)
else:
with raises(PropertiesOptionError):
cfg_.option(pathread).property.get()
with raises(PropertiesOptionError):
cfg_.option(pathread).property.get()
raises(PropertiesOptionError, "cfg_.option(pathread).property.get()")
raises(PropertiesOptionError, "cfg_.option(pathread).property.get()")
assert set(cfg_.forcepermissive.option(pathread).property.get()) == set(props_permissive)
assert set(cfg_.forcepermissive.option(pathread).property.get()) == set(props)
assert set(cfg_.unrestraint.option(pathread).property.get()) == set(props_permissive)
@ -247,15 +227,11 @@ def _check_properties(cfg, mcfg, pathread, conf, kwargs, props_permissive, props
assert set(cfg_.option(pathread, 1).property.get()) == set(props_permissive)
assert set(cfg_.option(pathread, 1).property.get()) == set(props)
else:
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).property.get()
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).property.get()
raises(PropertiesOptionError, "cfg_.option(pathread, 0).property.get()")
raises(PropertiesOptionError, "cfg_.option(pathread, 0).property.get()")
#
with raises(PropertiesOptionError):
cfg_.option(pathread, 1).property.get()
with raises(PropertiesOptionError):
cfg_.option(pathread, 1).property.get()
raises(PropertiesOptionError, "cfg_.option(pathread, 1).property.get()")
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)
#
@ -267,8 +243,8 @@ def _check_properties(cfg, mcfg, pathread, conf, kwargs, props_permissive, props
def _property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi or a follower
multi = cfg.unrestraint.option(pathread).ismulti()
isfollower = cfg.unrestraint.option(pathread).isfollower()
multi = cfg.unrestraint.option(pathread).option.ismulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
# define properties
properties = copy(PROPERTIES_LIST)
@ -309,9 +285,9 @@ def _property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **
def _autocheck_get_value(cfg, pathread, conf, **kwargs):
set_permissive = kwargs.get('set_permissive', True)
multi = cfg.unrestraint.option(pathread).ismulti()
submulti_ = cfg.unrestraint.option(pathread).issubmulti()
isfollower = cfg.unrestraint.option(pathread).isfollower()
multi = cfg.unrestraint.option(pathread).option.ismulti()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
empty_value = kwargs['default']
if not multi:
first_value = FIRST_VALUE
@ -340,38 +316,32 @@ def _autocheck_get_value(cfg, pathread, conf, **kwargs):
assert cfg_.forcepermissive.option(pathread, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value
elif kwargs.get('permissive', False):
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).value.get()
raises(PropertiesOptionError, "cfg_.option(pathread, 0).value.get()")
assert cfg_.forcepermissive.option(pathread, 0).value.get() == empty_value
if set_permissive:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value
else:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == empty_value
else:
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).value.get()
raises(PropertiesOptionError, "cfg_.option(pathread, 0).value.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).value.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(pathread).value.get() == first_value
assert cfg_.forcepermissive.option(pathread).value.get() == first_value
elif kwargs.get('permissive', False):
with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()")
if set_permissive:
assert cfg_.forcepermissive.option(pathread).value.get() == first_value
else:
assert cfg_.forcepermissive.option(pathread).value.get() == empty_value
else:
with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).value.get()
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).value.get()")
def _check_owner(cfg, pathread, conf, kwargs, owner, permissive_owner):
isfollower = cfg.unrestraint.option(pathread).isfollower()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
if conf is not None:
cfg_ = cfg.config(conf)
else:
@ -381,14 +351,11 @@ def _check_owner(cfg, pathread, conf, kwargs, owner, permissive_owner):
assert cfg_.option(pathread).owner.get() == owner
assert cfg_.forcepermissive.option(pathread).owner.get() == owner
elif not kwargs.get('propertyerror', False):
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.get()
raises(PropertiesOptionError, "cfg_.option(pathread).owner.get()")
assert cfg_.forcepermissive.option(pathread).owner.get() == permissive_owner
else:
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).owner.get()
raises(PropertiesOptionError, "cfg_.option(pathread).owner.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).owner.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(pathread, 0).owner.get() == 'default'
@ -396,43 +363,32 @@ def _check_owner(cfg, pathread, conf, kwargs, owner, permissive_owner):
assert cfg_.option(pathread, 1).owner.get() == owner
assert cfg_.forcepermissive.option(pathread, 1).owner.get() == owner
elif not kwargs.get('propertyerror', False):
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.get()
with raises(PropertiesOptionError):
cfg_.option(pathread, 1).owner.get()
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg_.option(pathread, 1).owner.get()")
assert cfg_.forcepermissive.option(pathread, 0).owner.get() == 'default'
assert cfg_.forcepermissive.option(pathread, 1).owner.get() == permissive_owner
else:
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).owner.get()
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).owner.get()")
@autocheck
def autocheck_option_multi(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
#FIXME
if pathwrite in ['subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubodval1.firstval1', 'subod.subsubod.third', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2']:
return
if not kwargs.get('permissive_od', False):
cfg.option(pathread).ismulti()
cfg.option(pathread).issubmulti()
cfg.option(pathread).isleader()
cfg.option(pathread).isfollower()
cfg.option(pathread).option.ismulti()
cfg.option(pathread).option.issubmulti()
cfg.option(pathread).option.isleader()
cfg.option(pathread).option.isfollower()
else:
with raises(PropertiesOptionError):
cfg.option(pathread).ismulti()
with raises(PropertiesOptionError):
cfg.option(pathread).issubmulti()
with raises(PropertiesOptionError):
cfg.option(pathread).isleader()
with raises(PropertiesOptionError):
cfg.option(pathread).isfollower()
raises(PropertiesOptionError, "cfg.option(pathread).option.ismulti()")
raises(PropertiesOptionError, "cfg.option(pathread).option.issubmulti()")
raises(PropertiesOptionError, "cfg.option(pathread).option.isleader()")
raises(PropertiesOptionError, "cfg.option(pathread).option.isfollower()")
cfg.forcepermissive.option(pathread).ismulti()
cfg.forcepermissive.option(pathread).issubmulti()
cfg.forcepermissive.option(pathread).isleader()
cfg.forcepermissive.option(pathread).isfollower()
cfg.forcepermissive.option(pathread).option.ismulti()
cfg.forcepermissive.option(pathread).option.issubmulti()
cfg.forcepermissive.option(pathread).option.isleader()
cfg.forcepermissive.option(pathread).option.isfollower()
@ -440,9 +396,7 @@ def autocheck_option_multi(cfg, mcfg, pathread, pathwrite, confread, confwrite,
def autocheck_default_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""check different value of owner when any value is set to this option
"""
if pathwrite in ['subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2']:
return
isfollower = cfg.unrestraint.option(pathread).isfollower()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
# check if owner is a string "default" and 'isdefault'
def do(conf):
if conf is not None:
@ -457,23 +411,17 @@ def autocheck_default_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite,
assert cfg_.option(pathread).owner.isdefault()
assert cfg_.forcepermissive.option(pathread).owner.isdefault()
elif not kwargs.get('propertyerror', False):
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.get()
raises(PropertiesOptionError, "cfg_.option(pathread).owner.get()")
assert cfg_.forcepermissive.option(pathread).owner.get() == 'default'
#
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.isdefault()
raises(PropertiesOptionError, "cfg_.option(pathread).owner.isdefault()")
assert cfg_.forcepermissive.option(pathread).owner.isdefault()
else:
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).owner.get()
raises(PropertiesOptionError, "cfg_.option(pathread).owner.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).owner.get()")
#
with raises(PropertiesOptionError):
cfg_.option(pathread).owner.isdefault()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).owner.isdefault()
raises(PropertiesOptionError, "cfg_.option(pathread).owner.isdefault()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).owner.isdefault()")
#
assert cfg_.unrestraint.option(pathread).owner.get() == 'default'
assert cfg_.unrestraint.option(pathread).owner.isdefault()
@ -485,23 +433,17 @@ def autocheck_default_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite,
assert cfg_.option(pathread, 0).owner.isdefault()
assert cfg_.forcepermissive.option(pathread, 0).owner.isdefault()
elif not kwargs.get('propertyerror', False):
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.get()
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()")
assert cfg_.forcepermissive.option(pathread, 0).owner.get() == 'default'
#
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.isdefault()
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.isdefault()")
assert cfg_.forcepermissive.option(pathread, 0).owner.isdefault()
else:
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).owner.get()
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).owner.get()")
#
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).owner.isdefault()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread, 0).owner.isdefault()
raises(PropertiesOptionError, "cfg_.option(pathread, 0).owner.isdefault()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread, 0).owner.isdefault()")
assert cfg_.unrestraint.option(pathread, 0).owner.get() == 'default'
assert cfg_.unrestraint.option(pathread, 0).owner.isdefault()
do(confread)
@ -524,9 +466,9 @@ def autocheck_set_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
@autocheck
def autocheck_get_value_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
multi = cfg.unrestraint.option(pathread).ismulti()
submulti_ = cfg.unrestraint.option(pathread).issubmulti()
isfollower = cfg.unrestraint.option(pathread).isfollower()
multi = cfg.unrestraint.option(pathread).option.ismulti()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
_set_value(cfg, pathwrite, confwrite, **kwargs)
empty_value = kwargs['default']
if not multi:
@ -553,38 +495,29 @@ def autocheck_get_value_permissive(cfg, mcfg, pathread, pathwrite, confread, con
assert cfg_.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
assert cfg_.forcepermissive.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
elif kwargs.get('permissive', False):
with raises(PropertiesOptionError):
assert cfg_.option(pathread, 0).value.get()
with raises(PropertiesOptionError):
assert cfg_.option(pathread, 1).value.get()
raises(PropertiesOptionError, "assert cfg_.option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert cfg_.option(pathread, 1).value.get()")
assert cfg_.forcepermissive.option(pathread, 0).value.get() == empty_value
if submulti_:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1]
else:
assert cfg_.forcepermissive.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
else:
with raises(PropertiesOptionError):
assert cfg_.option(pathread, 0).value.get()
with raises(PropertiesOptionError):
assert cfg_.option(pathread, 1).value.get()
with raises(PropertiesOptionError):
assert cfg_.forcepermissive.option(pathread, 0).value.get()
with raises(PropertiesOptionError):
assert cfg_.forcepermissive.option(pathread, 1).value.get()
raises(PropertiesOptionError, "assert cfg_.option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert cfg_.option(pathread, 1).value.get()")
raises(PropertiesOptionError, "assert cfg_.forcepermissive.option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert cfg_.forcepermissive.option(pathread, 1).value.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
with warnings.catch_warnings(record=True) as w:
assert cfg_.option(pathread).value.get() == first_value
assert cfg_.forcepermissive.option(pathread).value.get() == first_value
elif kwargs.get('permissive', False):
with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()")
assert cfg_.forcepermissive.option(pathread).value.get() == first_value
else:
with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
with raises(PropertiesOptionError):
cfg_.forcepermissive.option(pathread).value.get()
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()")
raises(PropertiesOptionError, "cfg_.forcepermissive.option(pathread).value.get()")
with warnings.catch_warnings(record=True) as w:
do(confread)
if confread != confwrite:
@ -606,16 +539,13 @@ def autocheck_get_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
@autocheck
def autocheck_value_follower(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
#FIXME
if pathwrite in ['odleader.third', 'subodval1.subsubodval1.thirdval1', 'subodval2.subsubodval2.thirdval2']:
return
isfollower = cfg.unrestraint.option(pathread).isfollower()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
if not isfollower:
return
if kwargs.get('propertyerror', False):
return
submulti_ = cfg.forcepermissive.option(pathread).issubmulti()
submulti_ = cfg.forcepermissive.option(pathread).option.issubmulti()
empty_value = kwargs['default']
def do(conf):
@ -656,9 +586,9 @@ def autocheck_value_follower(cfg, mcfg, pathread, pathwrite, confread, confwrite
@autocheck
def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi, a leader or a follower
multi = cfg.unrestraint.option(pathread).ismulti()
submulti_ = cfg.unrestraint.option(pathread).issubmulti()
isfollower = cfg.unrestraint.option(pathread).isfollower()
multi = cfg.unrestraint.option(pathread).option.ismulti()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
# set default value (different if value is multi or not)
if not multi:
@ -683,12 +613,12 @@ def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg_.option(pathwrite).value.reset()
#else:
#FIXME with raises(PropertiesOptionError):cfg.config(confwrite).option(pathwrite).value.reset()")
#FIXME raises(PropertiesOptionError, "cfg.config(confwrite).option(pathwrite).value.reset()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg_.option(pathwrite, 0).value.reset()
#else:
#FIXME with raises(PropertiesOptionError):cfg.config(confwrite).option(pathwrite, 0).value.reset()")
#FIXME raises(PropertiesOptionError, "cfg.config(confwrite).option(pathwrite, 0).value.reset()")
# get value after reset value without permissive
def do(conf):
@ -701,16 +631,14 @@ def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
assert cfg_.option(pathread, 0).value.get() == empty_value
assert cfg_.option(pathread, 1).value.get() == second_value[1]
elif kwargs.get('permissive', False):
with raises(PropertiesOptionError):
cfg_.option(pathread, 0).value.get()
raises(PropertiesOptionError, "cfg_.option(pathread, 0).value.get()")
assert cfg_.forcepermissive.option(pathread, 0).value.get() == empty_value
assert cfg_.forcepermissive.option(pathread, 1).value.get() == second_value[1]
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg_.option(pathread).value.get() == empty_value
elif kwargs.get('permissive', False):
with raises(PropertiesOptionError):
cfg_.option(pathread).value.get()
raises(PropertiesOptionError, "cfg_.option(pathread).value.get()")
assert cfg_.forcepermissive.option(pathread).value.get() == first_value
with warnings.catch_warnings(record=True) as w:
do(confread)
@ -720,8 +648,8 @@ def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
@autocheck
def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
isleader = cfg.unrestraint.option(pathread).isleader()
submulti_ = cfg.unrestraint.option(pathread).issubmulti()
isleader = cfg.unrestraint.option(pathread).option.isleader()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
if not isleader:
return
if confread is not None:
@ -739,6 +667,8 @@ def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite,
v3 = cfg_.forcepermissive.option(pathread).value.get()
len_value = len(leader_value)
leader_value.append(undefined)
print('debut', leader_value, cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0])
print(id(leader_value), id(cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0]))
assert len(cfg_.forcepermissive.option(pathread).value.get()) == len_value
with warnings.catch_warnings(record=True) as w:
cfg2_.forcepermissive.option(pathread).value.set(leader_value)
@ -758,7 +688,12 @@ def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite,
value = 'value'
else:
value = ['value']
print('==>>>')
print(leader_value, cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0])
print(id(leader_value), id(cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0]))
leader_value.append(value)
print(leader_value, cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0])
print(id(leader_value), id(cfg_._config_bag.context._impl_values_cache._cache['odleader.first'][None][0]))
assert len(cfg_.forcepermissive.option(pathread).value.get()) == len(new_leader_value)
cfg2_.forcepermissive.option(pathread).value.set(leader_value)
assert cfg_.forcepermissive.option(pathread).value.get()[-1] == value
@ -766,8 +701,8 @@ def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite,
@autocheck
def autocheck_pop_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
isleader = cfg.unrestraint.option(pathread).isleader()
submulti_ = cfg.unrestraint.option(pathread).issubmulti()
isleader = cfg.unrestraint.option(pathread).option.isleader()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
if not isleader:
return
@ -826,7 +761,7 @@ def autocheck_pop_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
@autocheck
def autocheck_reset_value_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi, a leader or a follower
isfollower = cfg.unrestraint.option(pathread).isfollower()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
_set_value(cfg, pathwrite, confwrite, **kwargs)
# reset value with permissive
with warnings.catch_warnings(record=True) as w:
@ -850,49 +785,46 @@ def autocheck_reset_value_permissive(cfg, mcfg, pathread, pathwrite, confread, c
cfg.forcepermissive.option(pathwrite, 1).value.reset()
#FIXME else:
# if not isfollower:
# with raises(PropertiesOptionError):cfg.forcepermissive.config(confwrite).option(pathwrite).value.reset()")
# raises(PropertiesOptionError, "cfg.forcepermissive.config(confwrite).option(pathwrite).value.reset()")
# else:
# with raises(PropertiesOptionError):cfg.forcepermissive.option(pathwrite, 1).value.reset()")
# raises(PropertiesOptionError, "cfg.forcepermissive.option(pathwrite, 1).value.reset()")
_autocheck_default_value(cfg, pathread, confread, **kwargs)
if confread != confwrite:
_autocheck_default_value(cfg, pathwrite, confwrite, **kwargs)
#FIXME
#FIXME
#FIXME@autocheck
#FIXMEdef autocheck_display(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
#FIXME """re set value
#FIXME """
#FIXME if kwargs['callback']:
#FIXME return
#FIXME make_dict = kwargs['make_dict']
#FIXME make_dict_value = kwargs['make_dict_value']
#FIXME if confread is not None:
#FIXME cfg_ = cfg.config(confread)
#FIXME else:
#FIXME cfg_ = cfg
#FIXME if confwrite is not None:
#FIXME cfg2_ = cfg.config(confwrite)
#FIXME else:
#FIXME cfg2_ = cfg
#FIXME assert cfg_.value.dict() == make_dict
#FIXME if confread != confwrite:
#FIXME assert(cfg2_.value.dict()) == make_dict
#FIXME _set_value(cfg, pathwrite, confwrite, **kwargs)
#FIXME assert cfg_.value.dict() == make_dict_value
#FIXME if confread != confwrite:
#FIXME assert(cfg2_.value.dict()) == make_dict_value
@autocheck
def autocheck_display(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""re set value
"""
if kwargs['callback']:
return
make_dict = kwargs['make_dict']
make_dict_value = kwargs['make_dict_value']
if confread is not None:
cfg_ = cfg.config(confread)
else:
cfg_ = cfg
if confwrite is not None:
cfg2_ = cfg.config(confwrite)
else:
cfg2_ = cfg
assert cfg_.value.dict() == make_dict
if confread != confwrite:
assert(cfg2_.value.dict()) == make_dict
_set_value(cfg, pathwrite, confwrite, **kwargs)
assert cfg_.value.dict() == make_dict_value
if confread != confwrite:
assert(cfg2_.value.dict()) == make_dict_value
@autocheck
def autocheck_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""get property from path
"""
#FIXME
if pathwrite in ['odleader.first', 'subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2', 'subodval1.subsubodval1.firstval1', 'subodval1.subsubodval1.secondval1', 'subodval1.subsubodval1.thirdval1', 'subodval2.subsubodval2.firstval2', 'subodval2.subsubodval2.secondval2', 'subodval2.subsubodval2.thirdval2']:
return
# check if is a multi or a follower
multi = cfg.unrestraint.option(pathread).ismulti()
isfollower = cfg.unrestraint.option(pathread).isfollower()
multi = cfg.unrestraint.option(pathread).option.ismulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
default_props, properties = _getproperties(multi, isfollower, kwargs)
@ -917,9 +849,6 @@ def autocheck_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kw
@autocheck
def autocheck_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
#FIXME
if pathwrite in ['odleader.first', 'subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2', 'subodval1.subsubodval1.firstval1', 'subodval1.subsubodval1.secondval1', 'subodval1.subsubodval1.thirdval1', 'subodval2.subsubodval2.firstval2', 'subodval2.subsubodval2.secondval2', 'subodval2.subsubodval2.thirdval2']:
return
_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs)
@ -927,12 +856,9 @@ def autocheck_property_permissive(cfg, mcfg, pathread, pathwrite, confread, conf
def autocheck_reset_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""check properties after set with permissive
"""
#FIXME
if pathwrite in ['odleader.first', 'subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2', 'subodval1.subsubodval1.firstval1', 'subodval1.subsubodval1.secondval1', 'subodval1.subsubodval1.thirdval1', 'subodval2.subsubodval2.firstval2', 'subodval2.subsubodval2.secondval2', 'subodval2.subsubodval2.thirdval2']:
return
# check if is a multi or a follower
multi = cfg.unrestraint.option(pathread).ismulti()
isfollower = cfg.unrestraint.option(pathread).isfollower()
multi = cfg.unrestraint.option(pathread).option.ismulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
default_props, properties = _getproperties(multi, isfollower, kwargs)
_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs)
@ -953,11 +879,8 @@ def autocheck_reset_property(cfg, mcfg, pathread, pathwrite, confread, confwrite
@autocheck
def autocheck_reset_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi or a follower
#FIXME
if pathwrite in ['odleader.first', 'subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2', 'subodval1.subsubodval1.firstval1', 'subodval1.subsubodval1.secondval1', 'subodval1.subsubodval1.thirdval1', 'subodval2.subsubodval2.firstval2', 'subodval2.subsubodval2.secondval2', 'subodval2.subsubodval2.thirdval2']:
return
multi = cfg.unrestraint.option(pathread).ismulti()
isfollower = cfg.unrestraint.option(pathread).isfollower()
multi = cfg.unrestraint.option(pathread).option.ismulti()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
default_props, properties = _getproperties(multi, isfollower, kwargs)
_property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs)
@ -979,8 +902,6 @@ def autocheck_context_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite,
def autocheck_owner_with_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""value is now changed, check owner in this case
"""
if pathwrite in ['odleader.first', 'subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2']:
return
_set_value(cfg, pathwrite, confwrite, **kwargs)
_check_owner(cfg, pathread, confwrite, kwargs, kwargs['owner'], kwargs['owner'])
if confread != confwrite:
@ -989,7 +910,7 @@ def autocheck_owner_with_value(cfg, mcfg, pathread, pathwrite, confread, confwri
@autocheck
def autocheck_default_owner_with_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
isfollower = cfg.unrestraint.option(pathread).isfollower()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
_set_value(cfg, pathwrite, confwrite, **kwargs)
if confwrite is not None:
@ -1005,8 +926,8 @@ def autocheck_default_owner_with_value(cfg, mcfg, pathread, pathwrite, confread,
if confwrite != confread:
assert cfg2_.option(pathread).owner.isdefault() is False
#FIXME else:
# with raises(PropertiesOptionError):cfg.config(confwrite).option(pathread).owner.isdefault()")
# with raises(PropertiesOptionError):cfg.config(confread).option(pathread).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathread).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confread).option(pathread).owner.isdefault()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg2_.option(pathread, 0).owner.isdefault() is True
@ -1015,14 +936,14 @@ def autocheck_default_owner_with_value(cfg, mcfg, pathread, pathwrite, confread,
assert cfg_.option(pathread, 0).owner.isdefault() is True
assert cfg_.option(pathread, 1).owner.isdefault() is False
#FIXME else:
# with raises(PropertiesOptionError):cfg.config(confwrite).option(pathread, 0).owner.isdefault()")
# with raises(PropertiesOptionError):cfg.config(confread).option(pathread, 0).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathread, 0).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confread).option(pathread, 0).owner.isdefault()")
@autocheck
def autocheck_default_owner_with_value_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a isfollower
isfollower = cfg.unrestraint.option(pathread).isfollower()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
_set_value(cfg, pathwrite, confwrite, **kwargs)
@ -1045,26 +966,22 @@ def autocheck_default_owner_with_value_permissive(cfg, mcfg, pathread, pathwrite
@autocheck
def autocheck_set_owner_no_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
isfollower = cfg.unrestraint.option(pathread).isfollower()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
if confwrite is not None:
cfg_ = cfg.forcepermissive.config(confwrite)
else:
cfg_ = cfg.forcepermissive
if not kwargs.get('propertyerror', False):
if not isfollower:
with raises(ConfigError):
cfg_.option(pathwrite).owner.set('new_user')
raises(ConfigError, "cfg_.option(pathwrite).owner.set('new_user')")
else:
with raises(ConfigError):
cfg_.option(pathwrite, 1).owner.set('new_user')
raises(ConfigError, "cfg_.option(pathwrite, 1).owner.set('new_user')")
@autocheck
def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# test set owner without permissive
if pathwrite in ['subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2']:
return
isfollower = cfg.unrestraint.option(pathread).isfollower()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
_set_value(cfg, pathwrite, confwrite, **kwargs)
if confwrite is not None:
@ -1076,17 +993,15 @@ def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
if not isfollower:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg_.option(pathwrite).owner.set('new_user')
with raises(ValueError):
cfg_.option(pathwrite).owner.set('default')
with raises(ValueError):
cfg_.option(pathwrite).owner.set('forced')
raises(ValueError, "cfg_.option(pathwrite).owner.set('default')")
raises(ValueError, "cfg_.option(pathwrite).owner.set('forced')")
#FIXME else:
# with raises(PropertiesOptionError):cfg.config(confwrite).option(pathwrite).owner.set('new_user')")
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathwrite).owner.set('new_user')")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg.option(pathwrite, 1).owner.set('new_user')
#FIXME else:
# with raises(PropertiesOptionError):cfg.option(pathwrite, 1).owner.set('new_user')")
# raises(PropertiesOptionError, "cfg.option(pathwrite, 1).owner.set('new_user')")
_check_owner(cfg, pathread, confwrite, kwargs, owners.new_user, kwargs['owner'])
if confwrite != confread:
@ -1095,9 +1010,7 @@ def autocheck_set_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
@autocheck
def autocheck_set_owner_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
if pathwrite in ['subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third', 'subod.subsubodval1.firstval1', 'subod.subsubodval1.secondval1', 'subod.subsubodval1.thirdval1', 'subod.subsubodval2.firstval2', 'subod.subsubodval2.secondval2', 'subod.subsubodval2.thirdval2']:
return
isfollower = cfg.unrestraint.option(pathread).isfollower()
isfollower = cfg.unrestraint.option(pathread).option.isfollower()
_set_value(cfg, pathwrite, confwrite, **kwargs)
if confwrite is not None:
@ -1113,10 +1026,10 @@ def autocheck_set_owner_permissive(cfg, mcfg, pathread, pathwrite, confread, con
cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user1')
#FIXME else:
# if not isfollower:
# with raises(PropertiesOptionError,
# raises(PropertiesOptionError,
# "cfg.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user1')")
# else:
# with raises(PropertiesOptionError,
# raises(PropertiesOptionError,
# "cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user1')")
_check_owner(cfg, pathread, confwrite, kwargs, 'new_user1', 'new_user1')
@ -1126,37 +1039,28 @@ def autocheck_set_owner_permissive(cfg, mcfg, pathread, pathwrite, confread, con
@autocheck
def autocheck_option(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
#FIXME
if pathwrite.endswith('val1') or pathwrite.endswith('val2') or pathwrite in ['subod.subsubod.first', 'subod.subsubod.second', 'subod.subsubod.third']:
return
expected_name = pathread.split('.')[-1]
if not kwargs.get('permissive_od', False):
current_name = cfg.option(pathread).name()
assert current_name == cfg.forcepermissive.option(pathread).name()
assert current_name == cfg.unrestraint.option(pathread).name()
doc = cfg.option(pathread).doc()
assert doc == cfg.forcepermissive.option(pathread).doc()
assert doc == cfg.unrestraint.option(pathread).doc()
current_name = cfg.option(pathread).option.name()
assert current_name == cfg.forcepermissive.option(pathread).option.name()
assert current_name == cfg.unrestraint.option(pathread).option.name()
doc = cfg.option(pathread).option.doc()
assert doc == cfg.forcepermissive.option(pathread).option.doc()
assert doc == cfg.unrestraint.option(pathread).option.doc()
elif not kwargs.get('propertyerror', False):
with raises(PropertiesOptionError):
cfg.option(pathread).name()
current_name = cfg.forcepermissive.option(pathread).name()
assert current_name == cfg.unrestraint.option(pathread).name()
with raises(PropertiesOptionError):
cfg.option(pathread).doc()
doc = cfg.forcepermissive.option(pathread).doc()
assert doc == cfg.unrestraint.option(pathread).doc()
raises(PropertiesOptionError, "cfg.option(pathread).option.name()")
current_name = cfg.forcepermissive.option(pathread).option.name()
assert current_name == cfg.unrestraint.option(pathread).option.name()
raises(PropertiesOptionError, "cfg.option(pathread).option.doc()")
doc = cfg.forcepermissive.option(pathread).option.doc()
assert doc == cfg.unrestraint.option(pathread).option.doc()
else:
with raises(PropertiesOptionError):
cfg.option(pathread).name()
with raises(PropertiesOptionError):
cfg.forcepermissive.option(pathread).name()
current_name = cfg.unrestraint.option(pathread).name()
with raises(PropertiesOptionError):
cfg.option(pathread).doc()
with raises(PropertiesOptionError):
cfg.forcepermissive.option(pathread).doc()
doc = cfg.unrestraint.option(pathread).doc()
raises(PropertiesOptionError, "cfg.option(pathread).option.name()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.name()")
current_name = cfg.unrestraint.option(pathread).option.name()
raises(PropertiesOptionError, "cfg.option(pathread).option.doc()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.doc()")
doc = cfg.unrestraint.option(pathread).option.doc()
assert current_name == expected_name
if expected_name.endswith('val1') or expected_name.endswith('val2'):
expected_name = expected_name[:-4]
@ -1179,11 +1083,7 @@ def autocheck_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **
cfg2_ = cfg.config(confread).unrestraint
else:
cfg2_ = cfg.unrestraint
if not cfg_.option(pathread).isfollower():
assert cfg_.option(pathread).permissive.get() == frozenset()
else:
assert cfg_.option(pathread, 0).permissive.get() == frozenset()
assert cfg_.option(pathread).permissive.get() == frozenset()
if kwargs.get('permissive_od', False):
assert cfg_.option(pathread.rsplit('.', 1)[0]).permissive.get() == frozenset()
@ -1204,10 +1104,7 @@ def autocheck_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **
cfg_.option(call_path).permissive.set(frozenset(['disabled']))
# have permissive?
if not cfg_.option(pathread).isfollower():
assert cfg_.option(pathread).permissive.get() == frozenset(['disabled'])
else:
assert cfg_.option(pathread, 0).permissive.get() == frozenset(['disabled'])
assert cfg_.option(pathread).permissive.get() == frozenset(['disabled'])
#if confwrite != confread:
# assert cfg.config(confread).unrestraint.option(pathread).permissive.get() == frozenset(['disabled'])
@ -1261,13 +1158,13 @@ def autocheck_option_get(cfg, mcfg, pathread, pathwrite, confread, confwrite, **
name = pathread.rsplit('.', 1)[1]
else:
name = pathread
assert cfg.unrestraint.option(pathread).name() == name
assert cfg.unrestraint.option(pathread).option.name() == name
@autocheck
def autocheck_find(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
def _getoption(opt):
opt = opt.get()
opt = opt.option.get()
if opt.impl_is_dynsymlinkoption():
opt = opt.opt
return opt
@ -1293,14 +1190,11 @@ def autocheck_find(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs
assert option == _getoption(cfg_.option.find(name, first=True))
assert option == _getoption(cfg_.forcepermissive.option.find(name, first=True))
elif kwargs.get('permissive', False):
with raises(AttributeError):
cfg_.option.find(name, first=True)
raises(AttributeError, "cfg_.option.find(name, first=True)")
assert option == _getoption(cfg_.forcepermissive.option.find(name, first=True))
else:
with raises(AttributeError):
cfg_.option.find(name, first=True)
with raises(AttributeError):
cfg_.forcepermissive.option.find(name, first=True)
raises(AttributeError, "cfg_.option.find(name, first=True)")
raises(AttributeError, "cfg_.forcepermissive.option.find(name, first=True)")
assert option == _getoption(cfg_.unrestraint.option.find(name, first=True))
assert [option] == _getoptions(cfg_.unrestraint.option.find(name))
do(confread)
@ -1478,11 +1372,11 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
for func in autocheck_registers:
cfg_name = 'conftest' + str(idx)
idx += 1
ncfg = cfg.config.copy(name=cfg_name)
ncfg = cfg.config.copy(session_id=cfg_name)
if meta:
confwrite = None
confread = cfg_name
mcfg = MetaConfig([ncfg], name='metatest')
mcfg = MetaConfig([ncfg], session_id='metatest')
weakrefs.append(weakref.ref(cfg))
else:
mcfg = ncfg
@ -1493,7 +1387,7 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
else:
ckwargs['owner'] = OWNER
if mcfg.unrestraint.option(path).isfollower():
if mcfg.unrestraint.option(path).option.isfollower():
dirname = path.rsplit('.', 1)[0]
leader_path = dirname + '.first'
leader_path_2 = None
@ -1651,11 +1545,11 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
call_kwargs['requires'] = option_requires
else:
kwargs['requires'] = option_requires
if multi and path != 'extraoptrequire':
if multi and path is not 'extraoptrequire':
kwargs['multi'] = multi
if callback:
call_kwargs['multi'] = multi
if ((not in_leader or leader) and default) and path != 'extraoptrequire' and not path.endswith('extraoptconsistency'):
if ((not in_leader or leader) and default) and path is not 'extraoptrequire' and not path.endswith('extraoptconsistency'):
if multi is False:
value = FIRST_VALUE
elif multi is True:
@ -1669,7 +1563,7 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
kwargs['default'] = value
elif callback:
return None, None, None
if default_multi and path != 'extraoptrequire':
if default_multi and path is not 'extraoptrequire':
if multi is not submulti:
value = SECOND_VALUE
else:
@ -1691,6 +1585,7 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
tiramisu_option = SymLinkOption
else:
sobj = None
print(args, kwargs)
obj = tiramisu_option(*args, **kwargs)
return obj, objcall, sobj
@ -1783,7 +1678,7 @@ def make_conf(options, multi, default, default_multi, require, callback, symlink
rootod = make_optiondescriptions('root', collect_options)
if rootod is None:
return None, None, None
cfg = Config(rootod, name='conftest')
cfg = Config(rootod, session_id='conftest')
weakrefs.append(weakref.ref(cfg))
del goptions
return cfg, weakrefs, dyn

49
tests/config.py
View file

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

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

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

2
tests/dict/data/choice1_requires.py
View file

@ -6,7 +6,7 @@ def get_description():
option1 = ChoiceOption('choice', "Choice description", ("hide", "show"), default='hide', properties=('mandatory',))
hidden_property = Calculation(calc_value,
Params(ParamValue('hidden'),
kwargs={'condition': ParamOption(option1),
kwargs={'condition': ParamOption(option1, todict=True),
'expected': ParamValue('hide')}))
option2 = StrOption('unicode2', "Unicode 2", properties=(hidden_property,))
descr1 = OptionDescription("options", "Common configuration", [option1, option2])

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

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

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

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

4
tests/dict/data/unicode1.dict
View file

@ -1,3 +1 @@
{
"options.unicode": null
}
{"options.unicode": null}

4
tests/dict/data/unicode1.dict1
View file

@ -1,3 +1 @@
{
"options.unicode": "val"
}
{"options.unicode": "val"}

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

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

2
tests/dict/data/unicode1_leadership_requires.py
View file

@ -8,7 +8,7 @@ def get_description():
option2 = StrOption('unicode2', "Values 'test' must show 'Unicode follower 3'", multi=True)
hidden_property = Calculation(calc_value,
Params(ParamValue('hidden'),
kwargs={'condition': ParamOption(option2),
kwargs={'condition': ParamOption(option2, todict=True),
'expected': ParamValue('test'),
'reverse_condition': ParamValue(True)}))
option3 = StrOption('unicode3', "Unicode follower 3", properties=(hidden_property,), multi=True)

2
tests/dict/data/unicode1_leadership_requires_all.py
View file

@ -10,7 +10,7 @@ def get_description():
option3 = StrOption('unicode3', "Unicode follower 2", multi=True)
hidden_property = Calculation(calc_value,
Params(ParamValue('hidden'),
kwargs={'condition': ParamOption(option),
kwargs={'condition': ParamOption(option, todict=True),
'expected': ParamValue('test'),
'reverse_condition': ParamValue(True)}))
descr1 = Leadership("unicode1", "Common configuration",

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

@ -9,7 +9,7 @@ def get_description():
option2 = StrOption('unicode2', "Unicode follower 2", multi=True)
disabled_property = Calculation(calc_value,
Params(ParamValue('disabled'),
kwargs={'condition': ParamOption(option),
kwargs={'condition': ParamOption(option, todict=True),
'expected': ParamValue('test'),
'reverse_condition': ParamValue(True)}))
option3 = StrOption('unicode3', "Unicode follower 3", properties=(disabled_property,), multi=True)
@ -20,14 +20,14 @@ def get_description():
return descr
def get_values(api, allpath=False):
async def get_values(api, allpath=False):
if allpath:
root = 'unicode1_leadership_requires_disabled_value.'
else:
root = ''
api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2'])
api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
api.option(root + 'options.unicode.unicode2', 1).value.set(u'test')
api.option(root + 'options.unicode.unicode3', 1).value.set(u'super')
await api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2'])
await api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
await api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
await api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
await api.option(root + 'options.unicode.unicode2', 1).value.set(u'test')
await api.option(root + 'options.unicode.unicode3', 1).value.set(u'super')

2
tests/dict/data/unicode1_leadership_requires_follower.py
View file

@ -8,7 +8,7 @@ def get_description():
option2 = StrOption('unicode2', "Unicode follower 1", multi=True)
hidden_property = Calculation(calc_value,
Params(ParamValue('hidden'),
kwargs={'condition': ParamOption(option1),
kwargs={'condition': ParamOption(option1, todict=True),
'expected': ParamValue('test'),
'reverse_condition': ParamValue(True)}))
option3 = StrOption('unicode3', "Unicode follower 2", multi=True, properties=(hidden_property,))

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

@ -8,7 +8,7 @@ def get_description():
option2 = StrOption('unicode2', "Unicode follower 1", multi=True)
hidden_property = Calculation(calc_value,
Params(ParamValue('hidden'),
kwargs={'condition': ParamOption(option1),
kwargs={'condition': ParamOption(option1, todict=True),
'expected': ParamValue('test'),
'reverse_condition': ParamValue(True)}))
option3 = StrOption('unicode3', "Unicode follower 2", multi=True, properties=(hidden_property,))
@ -19,11 +19,11 @@ def get_description():
return descr
def get_values(api, allpath=False):
async def get_values(api, allpath=False):
if allpath:
root = 'unicode1_leadership_requires_follower_value.'
else:
root = ''
api.option(root + 'options.unicode1.unicode1').value.set([u'test', u'pas test'])
api.option(root + 'options.unicode1.unicode2', 0).value.set(u'super1')
api.option(root + 'options.unicode1.unicode3', 0).value.set(u'super1')
await api.option(root + 'options.unicode1.unicode1').value.set([u'test', u'pas test'])
await api.option(root + 'options.unicode1.unicode2', 0).value.set(u'super1')
await api.option(root + 'options.unicode1.unicode3', 0).value.set(u'super1')

2
tests/dict/data/unicode1_leadership_requires_followers.py
View file

@ -8,7 +8,7 @@ def get_description():
option2 = StrOption('unicode2', "Values 'test' must show 'Unicode follower 2'", multi=True)
hidden_property = Calculation(calc_value,
Params(ParamValue('hidden'),
kwargs={'condition': ParamOption(option2),
kwargs={'condition': ParamOption(option2, todict=True),
'expected': ParamValue('test'),
'reverse_condition': ParamValue(True)}))
option3 = StrOption('unicode3', "Unicode follower 2", multi=True, properties=(hidden_property,))

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

@ -9,7 +9,7 @@ def get_description():
option2 = StrOption('unicode2', "Unicode follower 2", multi=True)
hidden_property = Calculation(calc_value,
Params(ParamValue('hidden'),
kwargs={'condition': ParamOption(option),
kwargs={'condition': ParamOption(option, todict=True),
'expected': ParamValue('test'),
'reverse_condition': ParamValue(True)}))
option3 = StrOption('unicode3', "Unicode follower 3", properties=(hidden_property,), multi=True)
@ -20,14 +20,14 @@ def get_description():
return descr
def get_values(api, allpath=False):
async def get_values(api, allpath=False):
if allpath:
root = 'unicode1_leadership_requires_value.'
else:
root = ''
api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2'])
api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
api.option(root + 'options.unicode.unicode2', 1).value.set(u'test')
api.option(root + 'options.unicode.unicode3', 1).value.set(u'super')
await api.option(root + 'options.unicode.unicode').value.set([u'test', u'val2'])
await api.option(root + 'options.unicode.unicode1', 0).value.set(u'super1')
await api.option(root + 'options.unicode.unicode1', 1).value.set(u'super2')
await api.option(root + 'options.unicode.unicode2', 0).value.set(u'pas test')
await api.option(root + 'options.unicode.unicode2', 1).value.set(u'test')
await api.option(root + 'options.unicode.unicode3', 1).value.set(u'super')

20
tests/dict/data/unicode1_leadership_value.dict
View file

@ -1,16 +1,4 @@
{
"options.unicode.unicode": [
{
"options.unicode.unicode": "val3",
"options.unicode.unicode1": "super1",
"options.unicode.unicode2": "pas test",
"options.unicode.unicode3": null
},
{
"options.unicode.unicode": "val4",
"options.unicode.unicode1": "super2",
"options.unicode.unicode2": "test",
"options.unicode.unicode3": "super"
}
]
}
{"options.unicode.unicode": ["val3", "val4"],
"options.unicode.unicode1": ["super1", "super2"],
"options.unicode.unicode2": ["pas test", "test"],
"options.unicode.unicode3": [null, "super"]}

20
tests/dict/data/unicode1_leadership_value.dict1
View file

@ -1,16 +1,4 @@
{
"options.unicode.unicode": [
{
"options.unicode.unicode": "val1",
"options.unicode.unicode1": null,
"options.unicode.unicode2": "follower2",
"options.unicode.unicode3": null
},
{
"options.unicode.unicode": "val2",
"options.unicode.unicode1": null,
"options.unicode.unicode2": "follower2",
"options.unicode.unicode3": null
}
]
}
{"options.unicode.unicode": ["val1", "val2"],
"options.unicode.unicode1": [null, null],
"options.unicode.unicode2": ["follower2", "follower2"],
"options.unicode.unicode3": [null, null]}

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

@ -1,10 +1,4 @@
{
"options.unicode.unicode": [
{
"options.unicode.unicode": "val3",
"options.unicode.unicode1": "super1",
"options.unicode.unicode2": "pas test",
"options.unicode.unicode3": null
}
]
}
{"options.unicode.unicode": ["val3"],
"options.unicode.unicode1": ["super1"],
"options.unicode.unicode2": ["pas test"],
"options.unicode.unicode3": [null]}

26
tests/dict/data/unicode1_leadership_value.dict3
View file

@ -1,22 +1,4 @@
{
"options.unicode.unicode": [
{
"options.unicode.unicode": "val3",
"options.unicode.unicode1": "super1",
"options.unicode.unicode2": "pas test",
"options.unicode.unicode3": null
},
{
"options.unicode.unicode": "val4",
"options.unicode.unicode1": "super2",
"options.unicode.unicode2": "test",
"options.unicode.unicode3": "super"
},
{
"options.unicode.unicode": "val5",
"options.unicode.unicode1": null,
"options.unicode.unicode2": "follower2",
"options.unicode.unicode3": null
}
]
}
{"options.unicode.unicode": ["val3", "val4", "val5"],
"options.unicode.unicode1": ["super1", "super2", null],
"options.unicode.unicode2": ["pas test", "test", "follower2"],
"options.unicode.unicode3": [null, "super", null]}

26
tests/dict/data/unicode1_leadership_value.dict4
View file

@ -1,22 +1,4 @@
{
"options.unicode.unicode": [
{
"options.unicode.unicode": "val3",
"options.unicode.unicode1": "super1",
"options.unicode.unicode2": "pas test",
"options.unicode.unicode3": null
},
{
"options.unicode.unicode": "val4",
"options.unicode.unicode1": "super2",
"options.unicode.unicode2": "test",
"options.unicode.unicode3": "super"
},
{
"options.unicode.unicode": "val5",
"options.unicode.unicode1": null,
"options.unicode.unicode2": "follower2",
"options.unicode.unicode3": null
}
]
}
{"options.unicode.unicode": ["val3", "val4", "val5"],
"options.unicode.unicode1": ["super1", "super2", null],
"options.unicode.unicode2": ["pas test", "test", "follower2"],
"options.unicode.unicode3": [null, "super", null]}

20
tests/dict/data/unicode1_leadership_value.dict5
View file

@ -1,16 +1,4 @@
{
"options.unicode.unicode": [
{
"options.unicode.unicode": "val3",
"options.unicode.unicode1": "super1",
"options.unicode.unicode2": "pas test",
"options.unicode.unicode3": null
},
{
"options.unicode.unicode": "val4",
"options.unicode.unicode1": "super2",
"options.unicode.unicode2": "follower2",
"options.unicode.unicode3": "super"
}
]
}
{"options.unicode.unicode": ["val3", "val4"],
"options.unicode.unicode1": ["super1", "super2"],
"options.unicode.unicode2": ["pas test", "follower2"],
"options.unicode.unicode3": [null, "super"]}

20
tests/dict/data/unicode1_leadership_value.dict6
View file

@ -1,16 +1,4 @@
{
"options.unicode.unicode": [
{
"options.unicode.unicode": "val3",
"options.unicode.unicode1": "super1",
"options.unicode.unicode2": "pas test",
"options.unicode.unicode3": null
},
{
"options.unicode.unicode": "val4",
"options.unicode.unicode1": "super2",
"options.unicode.unicode2": "test2",
"options.unicode.unicode3": "super"
}
]
}
{"options.unicode.unicode": ["val3", "val4"],
"options.unicode.unicode1": ["super1", "super2"],
"options.unicode.unicode2": ["pas test", "test2"],
"options.unicode.unicode3": [null, "super"]}

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

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

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

@ -1,3 +1 @@
{
"options.unicode": "a"
}
{"options.unicode": "a"}

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

@ -1,3 +1 @@
{
"options.unicode": "val"
}
{"options.unicode": "val"}

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

@ -1,3 +1 @@
{
"options.unicode": null
}
{"options.unicode": null}

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

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

4
tests/dict/data/unicode1_multi.dict
View file

@ -1,3 +1 @@
{
"options.unicode": []
}
{"options.unicode": []}

6
tests/dict/data/unicode1_multi.dict1
View file

@ -1,5 +1 @@
{
"options.unicode": [
"val"
]
}
{"options.unicode": ["val"]}

8
tests/dict/data/unicode1_multi_mod_value.dict
View file

@ -1,7 +1 @@
{
"options.unicode": [
"c",
"d",
"e"
]
}
{"options.unicode": ["c", "d", "e"]}

7
tests/dict/data/unicode1_multi_mod_value.dict1
View file

@ -1,6 +1 @@
{
"options.unicode": [
"a",
"b"
]
}
{"options.unicode": ["a", "b"]}

8
tests/dict/data/unicode1_multi_mod_value.dict2
View file

@ -1,7 +1 @@
{
"options.unicode": [
"c",
"f",
"e"
]
}
{"options.unicode": ["c", "f", "e"]}

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

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

2
tests/dict/data/unicode1_multi_requires.py
View file

@ -7,7 +7,7 @@ def get_description():
option1 = StrOption('unicode1', "Value 'test' must show Unicode 2")
hidden_property = Calculation(calc_value,
Params(ParamValue('hidden'),
kwargs={'condition': ParamOption(option1),
kwargs={'condition': ParamOption(option1, todict=True),
'expected': ParamValue('test'),
'reverse_condition': ParamValue(True)}))
option2 = StrOption('unicode2', "Unicode 2", properties=(hidden_property,), multi=True)

2
tests/dict/data/unicode1_optiondescription_requires.py
View file

@ -10,7 +10,7 @@ def get_description():
option3 = StrOption('unicode3', "Unicode 3")
hidden_property = Calculation(calc_value,
Params(ParamValue('hidden'),
kwargs={'condition': ParamOption(option1),
kwargs={'condition': ParamOption(option1, todict=True),
'expected': ParamValue('test'),
'reverse_condition': ParamValue(True)}))
descr2 = OptionDescription("unicode1", "OptionDescription with 2 options", [option2, option3], properties=(hidden_property,))

2
tests/dict/data/unicode1_requires.py
View file

@ -7,7 +7,7 @@ def get_description():
option1 = StrOption('unicode1', "Value 'test' must show Unicode 2")
hidden_property = Calculation(calc_value,
Params(ParamValue('hidden'),
kwargs={'condition': ParamOption(option1),
kwargs={'condition': ParamOption(option1, todict=True),
'expected': ParamValue('test'),
'reverse_condition': ParamValue(True)}))
option2 = StrOption('unicode2', "Unicode 2", properties=(hidden_property,))

106
tests/dict/test_json.py
View file

@ -23,8 +23,8 @@ def datapath():
def list_data(ext='.py'):
# if ext == '.py':
# return ['unicode1_leadership_requires.py']
# if ext == '.py':
# return ['choice1_leadership_hidden.py']
datadir = datapath()
filenames = listdir(datadir)
filenames.sort()
@ -36,31 +36,30 @@ def list_data(ext='.py'):
return ret
def load_config(filename,
add_extra_od=False,
remote='minimum',
clearable='minimum',
root=None,
):
async def load_config(filename,
add_extra_od=False,
remote='minimum',
clearable='minimum',
root=None):
modulepath = splitext(filename)[0]
mod = __import__(modulepath)
descr = mod.get_description()
if add_extra_od:
descr = OptionDescription('root', '', [descr])
config = Config(descr)
config.property.add('demoting_error_warning')
config = await Config(descr)
await config.property.add('demoting_error_warning')
if 'get_values' in dir(mod):
mod.get_values(config, add_extra_od)
await mod.get_values(config, add_extra_od)
form = [{'title': 'Configurer',
'type': 'submit'}]
if 'get_form' in dir(mod):
form.extend(mod.get_form(add_extra_od))
config.property.read_write()
await config.property.read_write()
if root is None:
values = loads(dumps(config.option.dict(remotable=remote, clearable=clearable, form=form)))
values = loads(dumps(await config.option.dict(remotable=remote, clearable=clearable, form=form)))
else:
values = loads(dumps(config.option(root).dict(remotable=remote, clearable=clearable, form=form)))
values = loads(dumps(await config.option(root).dict(remotable=remote, clearable=clearable, form=form)))
return values
@ -151,7 +150,8 @@ def filename_mod(request):
return request.param
def test_jsons(filename):
@pytest.mark.asyncio
async def test_jsons(filename):
debug = False
# debug = True
datadir = datapath()
@ -168,10 +168,9 @@ def test_jsons(filename):
modulepath = splitext(filename)[0]
if debug:
print(" {} (remote: {}, clearable: {})".format(filename, remote, clearable))
values = load_config(filename,
remote=remote,
clearable=clearable,
)
values = await load_config(filename,
remote=remote,
clearable=clearable)
#
if not isfile(join(datadir, modulepath + '.json')) and \
clearable == 'minimum' and \
@ -218,28 +217,8 @@ def test_jsons(filename):
assert values == expected, "error in file {}".format(filename)
def loads_yml(fh, issub, modulepath):
dico = loads(fh.read())
if issub:
new_dico_ori = {}
for key, value in dico.items():
key = modulepath + '.' + key
if isinstance(value, list):
new_value = []
for val in value:
if isinstance(val, dict):
new_val = {}
for k, v in val.items():
new_val[modulepath + '.' + k] = v
val = new_val
new_value.append(val)
value = new_value
new_dico_ori[key] = value
dico = new_dico_ori
return dico
def test_jsons_subconfig(filename):
@pytest.mark.asyncio
async def test_jsons_subconfig(filename):
debug = False
# debug = True
datadir = datapath()
@ -248,7 +227,7 @@ def test_jsons_subconfig(filename):
modulepath = splitext(filename)[0]
if debug:
print(" ", filename)
values = load_config(filename, add_extra_od=True, root=modulepath)
values = await load_config(filename, add_extra_od=True, root=modulepath)
#
with open(join(datadir, modulepath + '.json'), 'r') as fh:
expected = loads(fh.read())
@ -313,7 +292,8 @@ def test_jsons_subconfig(filename):
assert values == expected, "error in file {}".format(filename)
def test_updates(filename_mod):
@pytest.mark.asyncio
async def test_updates(filename_mod):
debug = False
# debug = True
datadir = datapath()
@ -334,7 +314,13 @@ def test_updates(filename_mod):
dico_ori = None
else:
with open(join(datadir, modulepath + '.dict'), 'r') as fh:
dico_ori = loads_yml(fh, issub, modulepath)
dico_ori = loads(fh.read())
if issub:
new_dico_ori = {}
for key, value in dico_ori.items():
key = modulepath + '.' + key
new_dico_ori[key] = value
dico_ori = new_dico_ori
# modify config
with open(join(datadir, modulepath + '.mod{}'.format(idx)), 'r') as fh:
body = loads(fh.read())['body']
@ -360,7 +346,13 @@ def test_updates(filename_mod):
dico_mod = None
else:
with open(join(datadir, modulepath + '.dict{}'.format(idx)), 'r') as fh:
dico_mod = loads_yml(fh, issub, modulepath)
dico_mod = loads(fh.read())
if issub:
new_dico = {}
for key, value in dico_mod.items():
key = modulepath + '.' + key
new_dico[key] = value
dico_mod = new_dico
if root is None:
root_path = ''
else:
@ -370,31 +362,31 @@ def test_updates(filename_mod):
if debug:
print(" (remote: {}, clearable: {}, issub {}, root {}, root_path {})".format(remote, clearable, issub, root, root_path))
for with_model in [False, True]:
config = Config(descr)
config.property.add('demoting_error_warning')
config = await Config(descr)
await config.property.add('demoting_error_warning')
if 'get_values' in dir(mod):
mod.get_values(config, issub)
await mod.get_values(config, issub)
if isfile(join(datadir, modulepath + '.mod')):
with open(join(datadir, modulepath + '.mod'), 'r') as fh:
eval(fh.read())
await eval(fh.read())
if dico_ori is None:
if clearable == 'minimum' and remote == 'minimum':
with open(join(datadir, modulepath + '.dict'), 'w') as fh:
dump(config.value.dict(), fh, indent=2)
dump(await config.value.dict(), fh, indent=2)
else:
assert config.value.dict() == dico_ori, "clearable {}, remote: {}, filename: {}".format(clearable, remote, filename_mod)
assert await config.value.dict() == dico_ori, "clearable {}, remote: {}, filename: {}".format(clearable, remote, filename_mod)
if root is None:
suboption = config.option
else:
suboption = config.option(root)
if with_model:
bodym = body.copy()
bodym['model'] = loads(dumps(suboption.dict(remotable=remote, clearable=clearable)))['model']
bodym['model'] = loads(dumps(await suboption.dict(remotable=remote, clearable=clearable)))['model']
else:
suboption.dict(remotable=remote, clearable=clearable)
await suboption.dict(remotable=remote, clearable=clearable)
bodym = body
if with_model:
cal_values = suboption.updates(bodym)
cal_values = await suboption.updates(bodym)
if values is None:
if clearable == 'minimum' and remote == 'minimum':
with open(join(datadir, modulepath + '.updates{}'.format(idx)), 'w') as fh:
@ -407,10 +399,10 @@ def test_updates(filename_mod):
pprint(values)
assert cal_values == values
else:
assert suboption.updates(bodym) == {}
assert await suboption.updates(bodym) == {}
if dico_mod is None:
if clearable == 'minimum' and remote == 'minimum':
with open(join(datadir, modulepath + '.dict{}'.format(idx)), 'w') as fh:
dump(config.value.dict(), fh, indent=2)
dump(await config.value.dict(), fh, indent=2)
else:
assert config.value.dict() == dico_mod
assert await config.value.dict() == dico_mod

932
tests/test_cache.py
View file

File diff suppressed because it is too large Load diff

358
tests/test_choice_option.py
View file

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

622
tests/test_config.py
View file

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

611
tests/test_config_api.py
View file

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

436
tests/test_config_domain.py
View file

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

667
tests/test_config_ip.py
View file

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

298
tests/test_dereference.py
View file

@ -7,40 +7,64 @@ import pytest
from tiramisu import BoolOption, IntOption, StrOption, IPOption, NetmaskOption, \
SymLinkOption, OptionDescription, DynOptionDescription, submulti, \
Config, GroupConfig, MetaConfig, Params, ParamOption, Calculation
from tiramisu.storage import list_sessions
from .config import event_loop
IS_DEREFABLE = True
def funcname(*args, **kwargs):
return value
def test_deref_value():
@pytest.mark.asyncio
async def test_deref_storage():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = Config(o)
w = weakref.ref(cfg._config_bag.context.get_values())
async with await Config(o) as cfg:
w = weakref.ref(cfg._config_bag.context.cfgimpl_get_values()._p_)
del cfg
assert w() is None
assert not await list_sessions()
def test_deref_setting():
@pytest.mark.asyncio
async def test_deref_value():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = Config(o)
w = weakref.ref(cfg._config_bag.context.get_settings())
async with await Config(o) as cfg:
w = weakref.ref(cfg._config_bag.context.cfgimpl_get_values())
del cfg
assert w() is None
assert not await list_sessions()
def test_deref_config():
@pytest.mark.asyncio
async def test_deref_setting():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = Config(o)
w = weakref.ref(cfg)
async with await Config(o) as cfg:
w = weakref.ref(cfg._config_bag.context.cfgimpl_get_settings())
del cfg
assert w() is None
assert not await list_sessions()
def test_deref_option():
@pytest.mark.asyncio
async def test_deref_config():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
async with await Config(o) as cfg:
w = weakref.ref(cfg)
del cfg
assert w() is None
assert not await list_sessions()
@pytest.mark.asyncio
async def test_deref_option():
global IS_DEREFABLE
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
w = weakref.ref(b)
@ -48,12 +72,17 @@ def test_deref_option():
try:
assert w() is not None
except AssertionError:
IS_DEREFABLE = False
return
del(o)
assert w() is None
assert not await list_sessions()
def test_deref_optiondescription():
@pytest.mark.asyncio
async def test_deref_optiondescription():
if not IS_DEREFABLE:
return
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
w = weakref.ref(o)
@ -61,169 +90,202 @@ def test_deref_optiondescription():
assert w() is not None
del(o)
assert w() is None
assert not await list_sessions()
def test_deref_option_cache():
@pytest.mark.asyncio
async def test_deref_option_cache():
if not IS_DEREFABLE:
return
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
o._build_cache()
await o._build_cache()
w = weakref.ref(b)
del(b)
assert w() is not None
del(o)
assert w() is None
assert not await list_sessions()
def test_deref_optiondescription_cache():
@pytest.mark.asyncio
async def test_deref_optiondescription_cache():
if not IS_DEREFABLE:
return
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
o._build_cache()
await o._build_cache()
w = weakref.ref(o)
del(b)
assert w() is not None
del(o)
assert w() is None
assert not await list_sessions()
def test_deref_option_config():
@pytest.mark.asyncio
async def test_deref_option_config():
if not IS_DEREFABLE:
return
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = Config(o)
w = weakref.ref(b)
del(b)
assert w() is not None
del(o)
assert w() is not None
async with await Config(o) as cfg:
w = weakref.ref(b)
del(b)
assert w() is not None
del(o)
assert w() is not None
del cfg
assert w() is None
assert not await list_sessions()
def test_deref_optiondescription_config():
@pytest.mark.asyncio
async def test_deref_optiondescription_config():
if not IS_DEREFABLE:
return
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
cfg = Config(o)
w = weakref.ref(o)
del(b)
assert w() is not None
del(o)
assert w() is not None
async with await Config(o) as cfg:
w = weakref.ref(o)
del(b)
assert w() is not None
del(o)
assert w() is not None
del cfg
assert w() is None
assert not await list_sessions()
def test_deref_validator():
@pytest.mark.asyncio
async def test_deref_validator():
if not IS_DEREFABLE:
return
a = StrOption('a', '', default='yes')
b = StrOption('b', '', validators=[Calculation(funcname, Params(ParamOption(a)))], default='val')
o = OptionDescription('root', '', [a, b])
cfg = Config(o)
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(o)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(a)
del(b)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(o)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
od = OptionDescription('root', '', [a, b])
async with await Config(od) as cfg:
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(od)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(a)
del(b)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(od)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del cfg
assert y() is None
assert z() is None
assert not await list_sessions()
def test_deref_callback():
@pytest.mark.asyncio
async def test_deref_callback():
if not IS_DEREFABLE:
return
a = StrOption('a', "", 'val')
b = StrOption('b', "", Calculation(funcname, Params((ParamOption(a),))))
o = OptionDescription('root', '', [a, b])
cfg = Config(o)
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(o)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(a)
del(b)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(o)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
od = OptionDescription('root', '', [a, b])
async with await Config(od) as cfg:
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(od)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(a)
del(b)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(od)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del cfg
assert y() is None
assert z() is None
assert not await list_sessions()
def test_deref_symlink():
@pytest.mark.asyncio
async def test_deref_symlink():
if not IS_DEREFABLE:
return
a = BoolOption("a", "", default=False)
b = SymLinkOption("b", a)
o = OptionDescription('root', '', [a, b])
cfg = Config(o)
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(o)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(a)
del(b)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(o)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
od = OptionDescription('root', '', [a, b])
async with await Config(od) as cfg:
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(od)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(a)
del(b)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(od)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del cfg
assert y() is None
assert z() is None
assert not await list_sessions()
def test_deref_dyn():
@pytest.mark.asyncio
async def test_deref_dyn():
if not IS_DEREFABLE:
return
a = StrOption('a', '', ['val1', 'val2'], multi=True)
b = StrOption('b', '')
dod = DynOptionDescription('dod', '', [b], suffixes=Calculation(funcname, Params((ParamOption(a),))))
o = OptionDescription('od', '', [dod, a])
cfg = Config(o)
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(o)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(a)
del(b)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(o)
del(dod)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
od = OptionDescription('od', '', [dod, a])
async with await Config(od) as cfg:
w = weakref.ref(a)
x = weakref.ref(b)
y = weakref.ref(od)
z = weakref.ref(cfg)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(a)
del(b)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del(od)
del(dod)
assert w() is not None
assert x() is not None
assert w() is not None
assert x() is not None
del cfg
assert y() is None
assert z() is None
assert not await list_sessions()

100
tests/test_duplicate_config.py
View file

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

2845
tests/test_dyn_optiondescription.py
View file

File diff suppressed because it is too large Load diff

252
tests/test_freeze.py
View file

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

1592
tests/test_leadership.py
View file

File diff suppressed because it is too large Load diff

1047
tests/test_mandatory.py
View file

File diff suppressed because it is too large Load diff

1779
tests/test_metaconfig.py
View file

File diff suppressed because it is too large Load diff

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

353
tests/test_option.py
View file

@ -6,25 +6,24 @@ do_autopath()
import pytest
import warnings
from tiramisu.error import ConfigError, ValueWarning
from tiramisu import IntOption, SymLinkOption, OptionDescription, Config, Calculation, groups
from tiramisu.error import APIError, ConfigError
from tiramisu import IntOption, SymLinkOption, OptionDescription, Config, Calculation, groups, list_sessions
from tiramisu.i18n import _
from .config import event_loop
try:
groups.family
except:
groups.addgroup('family')
groups.family = groups.GroupType('family')
def a_func():
return None
def display_name(*args):
return 'display_name'
def test_option_valid_name():
@pytest.mark.asyncio
async def test_option_valid_name():
IntOption('test', '')
with pytest.raises(ValueError):
IntOption(1, "")
@ -32,9 +31,22 @@ def test_option_valid_name():
with pytest.raises(ValueError):
SymLinkOption(1, i)
i = SymLinkOption("test1", i)
#
#
#@pytest.mark.asyncio
#async def test_option_unvalid_name():
# with pytest.raises(ValueError):
# IntOption('test.', '')
# with pytest.raises(ValueError):
# IntOption('test.val', '')
# with pytest.raises(ValueError):
# IntOption('.test', '')
# with pytest.raises(ValueError):
# OptionDescription('.test', '', [])
def test_option_get_information():
@pytest.mark.asyncio
async def test_option_get_information():
description = "it's ok"
string = 'some informations'
i = IntOption('test', description)
@ -48,12 +60,14 @@ def test_option_get_information():
assert i.impl_get_information('doc') == description
def test_option_get_information_config():
@pytest.mark.asyncio
async def test_option_get_information_config():
description = "it's ok"
string = 'some informations'
i = IntOption('test', description)
od = OptionDescription('od', '', [i])
cfg = Config(od)
async with await Config(od) as cfg:
pass
with pytest.raises(ValueError):
i.impl_get_information('noinfo')
with pytest.raises(AttributeError):
@ -62,56 +76,34 @@ def test_option_get_information_config():
i.impl_get_information('noinfo')
assert i.impl_get_information('noinfo', 'default') == 'default'
assert i.impl_get_information('doc') == description
# assert not list_sessions()
assert not await list_sessions()
def test_option_unknown():
@pytest.mark.asyncio
async def test_option_get_information_default():
description = "it's ok"
string = 'some informations'
i = IntOption('test', description)
i.impl_set_information('noinfo', 'optdefault')
od = OptionDescription('od', '', [i])
cfg = Config(od)
#
with pytest.raises(ConfigError):
cfg.option('test').unknown.get()
with pytest.raises(ConfigError):
# only choice
cfg.option('test').value.list()
async with await Config(od) as cfg:
#
assert await cfg.option('test').information.get('noinfo', 'falsedefault') == 'optdefault'
#
await cfg.option('test').information.set('noinfo', 'notdefault')
assert await cfg.option('test').information.get('noinfo', 'falsedefault') == 'notdefault'
assert not await list_sessions()
def test_option_description():
description = "it's ok"
i = IntOption('test', description)
od = OptionDescription('od', 'od', [i])
od2 = OptionDescription('od', '', [od])
cfg = Config(od2)
assert cfg.option('od').description() == 'od'
assert cfg.option('od.test').description() == description
def test_option_get_information_default():
description = "it's ok"
string = 'some informations'
i = IntOption('test', description)
i.impl_set_information('noinfo', 'optdefault')
od = OptionDescription('od', '', [i])
cfg = Config(od)
#
assert cfg.option('test').information.get('noinfo', 'falsedefault') == 'optdefault'
#
cfg.option('test').information.set('noinfo', 'notdefault')
assert cfg.option('test').information.get('noinfo', 'falsedefault') == 'notdefault'
# assert not list_sessions()
def test_option_get_information_config2():
@pytest.mark.asyncio
async def test_option_get_information_config2():
description = "it's ok"
string = 'some informations'
i = IntOption('test', description)
i.impl_set_information('info', string)
od = OptionDescription('od', '', [i])
cfg = Config(od)
async with await Config(od) as cfg:
pass
with pytest.raises(ValueError):
i.impl_get_information('noinfo')
with pytest.raises(AttributeError):
@ -121,10 +113,11 @@ def test_option_get_information_config2():
i.impl_get_information('noinfo')
assert i.impl_get_information('noinfo', 'default') == 'default'
assert i.impl_get_information('doc') == description
# assert not list_sessions()
assert not await list_sessions()
def test_optiondescription_get_information():
@pytest.mark.asyncio
async def test_optiondescription_get_information():
description = "it's ok"
string = 'some informations'
o = OptionDescription('test', description, [])
@ -134,31 +127,34 @@ def test_optiondescription_get_information():
o.impl_get_information('noinfo')
assert o.impl_get_information('noinfo', 'default') == 'default'
assert o.impl_get_information('doc') == description
# assert not list_sessions()
assert not await list_sessions()
def test_option_isoptiondescription():
@pytest.mark.asyncio
async def test_option_isoptiondescription():
i = IntOption('test', '')
od = OptionDescription('od', '', [i])
od = OptionDescription('od', '', [od])
cfg = Config(od)
assert cfg.option('od').isoptiondescription()
assert not cfg.option('od.test').isoptiondescription()
# assert not list_sessions()
async with await Config(od) as cfg:
assert await cfg.option('od').option.isoptiondescription()
assert not await cfg.option('od.test').option.isoptiondescription()
assert not await list_sessions()
def test_option_double():
@pytest.mark.asyncio
async def test_option_double():
i = IntOption('test', '')
od = OptionDescription('od1', '', [i])
od = OptionDescription('od2', '', [od])
od = OptionDescription('od3', '', [od])
cfg = Config(od)
assert cfg.option('od2.od1.test').value.get() is None
assert cfg.option('od2').option('od1').option('test').value.get() is None
# assert not list_sessions()
async with await Config(od) as cfg:
assert await cfg.option('od2.od1.test').value.get() is None
assert await cfg.option('od2').option('od1').option('test').value.get() is None
assert not await list_sessions()
def test_option_multi():
@pytest.mark.asyncio
async def test_option_multi():
IntOption('test', '', multi=True)
IntOption('test', '', multi=True, default_multi=1)
IntOption('test', '', default=[1], multi=True, default_multi=1)
@ -168,31 +164,40 @@ def test_option_multi():
#unvalid default_multi
with pytest.raises(ValueError):
IntOption('test', '', multi=True, default_multi='yes')
# assert not list_sessions()
assert not await list_sessions()
def test_unknown_option():
#@pytest.mark.asyncio
#async def test_option_multi_legacy():
# #not default_multi with callback
# #with pytest.raises(ValueError):
# IntOption('test', '', multi=True, default_multi=1, callback=a_func)")
@pytest.mark.asyncio
async def test_unknown_option():
i = IntOption('test', '')
od1 = OptionDescription('od', '', [i])
od2 = OptionDescription('od', '', [od1])
cfg = Config(od2)
# test is an option, not an optiondescription
with pytest.raises(TypeError):
cfg.option('od.test.unknown').value.get()
# unknown is an unknown option
with pytest.raises(AttributeError):
cfg.option('unknown').value.get()
# unknown is an unknown option
with pytest.raises(AttributeError):
cfg.option('od.unknown').value.get()
# unknown is an unknown optiondescription
with pytest.raises(AttributeError):
cfg.option('od.unknown.suboption').value.get()
# assert not list_sessions()
async with await Config(od2) as cfg:
# test is an option, not an optiondescription
with pytest.raises(TypeError):
await cfg.option('od.test.unknown').value.get()
# unknown is an unknown option
with pytest.raises(AttributeError):
await cfg.option('unknown').value.get()
# unknown is an unknown option
with pytest.raises(AttributeError):
await cfg.option('od.unknown').value.get()
# unknown is an unknown optiondescription
with pytest.raises(AttributeError):
await cfg.option('od.unknown.suboption').value.get()
assert not await list_sessions()
def test_optiondescription_list():
groups.addgroup('notfamily1')
@pytest.mark.asyncio
async def test_optiondescription_list():
groups.notfamily1 = groups.GroupType('notfamily1')
i = IntOption('test', '')
i2 = IntOption('test', '')
od1 = OptionDescription('od', '', [i])
@ -201,30 +206,31 @@ def test_optiondescription_list():
od3.impl_set_group_type(groups.notfamily1)
od2 = OptionDescription('od', '', [od1, od3])
od4 = OptionDescription('od', '', [od2])
cfg = Config(od4)
assert len(list(cfg.option('od').list('option'))) == 0
assert len(list(cfg.option('od').list('optiondescription'))) == 2
assert len(list(cfg.option('od').list('optiondescription', group_type=groups.family))) == 1
assert len(list(cfg.option('od').list('optiondescription', group_type=groups.notfamily1))) == 1
assert len(list(cfg.option('od.od').list('option'))) == 1
assert len(list(cfg.option('od.od2').list('option'))) == 1
try:
list(cfg.option('od').list('unknown'))
except AssertionError:
pass
else:
raise Exception('must raise')
try:
list(cfg.option('od').list('option', group_type='toto'))
except AssertionError:
pass
else:
raise Exception('must raise')
# assert not list_sessions()
async with await Config(od4) as cfg:
assert len(list(await cfg.option('od').list('option'))) == 0
assert len(list(await cfg.option('od').list('optiondescription'))) == 2
assert len(list(await cfg.option('od').list('optiondescription', group_type=groups.family))) == 1
assert len(list(await cfg.option('od').list('optiondescription', group_type=groups.notfamily1))) == 1
assert len(list(await cfg.option('od.od').list('option'))) == 1
assert len(list(await cfg.option('od.od2').list('option'))) == 1
try:
list(await cfg.option('od').list('unknown'))
except AssertionError:
pass
else:
raise Exception('must raise')
try:
list(await cfg.option('od').list('option', group_type='toto'))
except AssertionError:
pass
else:
raise Exception('must raise')
assert not await list_sessions()
def test_optiondescription_group():
groups.addgroup('notfamily')
@pytest.mark.asyncio
async def test_optiondescription_group():
groups.notfamily = groups.GroupType('notfamily')
i = IntOption('test', '')
i2 = IntOption('test', '')
od1 = OptionDescription('od', '', [i])
@ -232,29 +238,30 @@ def test_optiondescription_group():
od3 = OptionDescription('od2', '', [i2])
od3.impl_set_group_type(groups.notfamily)
od2 = OptionDescription('od', '', [od1, od3])
cfg = Config(od2)
assert len(list(cfg.option.list('option'))) == 0
assert len(list(cfg.option.list('optiondescription'))) == 2
assert len(list(cfg.option.list('optiondescription', group_type=groups.family))) == 1
assert len(list(cfg.option.list('optiondescription', group_type=groups.notfamily))) == 1
try:
list(cfg.option.list('unknown'))
except AssertionError:
pass
else:
raise Exception('must raise')
try:
list(cfg.option.list('option', group_type='toto'))
except AssertionError:
pass
else:
raise Exception('must raise')
# assert not list_sessions()
async with await Config(od2) as cfg:
assert len(list(await cfg.option.list('option'))) == 0
assert len(list(await cfg.option.list('optiondescription'))) == 2
assert len(list(await cfg.option.list('optiondescription', group_type=groups.family))) == 1
assert len(list(await cfg.option.list('optiondescription', group_type=groups.notfamily))) == 1
try:
list(await cfg.option.list('unknown'))
except AssertionError:
pass
else:
raise Exception('must raise')
try:
list(await cfg.option.list('option', group_type='toto'))
except AssertionError:
pass
else:
raise Exception('must raise')
assert not await list_sessions()
def test_optiondescription_group_redefined():
@pytest.mark.asyncio
async def test_optiondescription_group_redefined():
try:
groups.addgroup('notfamily')
groups.notfamily = groups.GroupType('notfamily')
except:
pass
i = IntOption('test', '')
@ -262,93 +269,59 @@ def test_optiondescription_group_redefined():
od1.impl_set_group_type(groups.family)
with pytest.raises(ValueError):
od1.impl_set_group_type(groups.notfamily)
# assert not list_sessions()
assert not await list_sessions()
def test_optiondescription_group_leadership():
@pytest.mark.asyncio
async def test_optiondescription_group_leadership():
i = IntOption('test', '')
od1 = OptionDescription('od', '', [i])
with pytest.raises(ConfigError):
od1.impl_set_group_type(groups.leadership)
# assert not list_sessions()
assert not await list_sessions()
def test_asign_optiondescription():
@pytest.mark.asyncio
async def test_asign_optiondescription():
i = IntOption('test', '')
od1 = OptionDescription('od', '', [i])
od2 = OptionDescription('od', '', [od1])
cfg = Config(od2)
with pytest.raises(ConfigError):
cfg.option('od').value.set('test')
with pytest.raises(ConfigError):
cfg.option('od').value.reset()
# assert not list_sessions()
async with await Config(od2) as cfg:
with pytest.raises(APIError):
await cfg.option('od').value.set('test')
with pytest.raises(APIError):
await cfg.option('od').value.reset()
assert not await list_sessions()
def test_intoption():
@pytest.mark.asyncio
async def test_intoption():
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(ValueError):
cfg.option('test1').value.set(2)
cfg.option('test1').value.set(3)
assert cfg.option('test1').value.valid() is True
cfg.option('test1').value.set(4)
cfg.option('test2').value.set(2)
cfg.option('test2').value.set(3)
with pytest.raises(ValueError):
cfg.option('test2').value.set(4)
warnings.simplefilter("always", ValueWarning)
with warnings.catch_warnings(record=True) as w:
cfg.option('test3').value.set(2)
assert cfg.option('test3').value.valid() is True
assert len(w) == 1
with warnings.catch_warnings(record=True) as w:
cfg.option('test3').value.set(7)
assert cfg.option('test3').value.valid() is True
cfg.option('test3').value.set(4)
assert cfg.option('test3').value.valid() is True
assert len(w) == 1
# assert not list_sessions()
od = OptionDescription('od', '', [i1, i2])
async with await Config(od) as cfg:
with pytest.raises(ValueError):
await cfg.option('test1').value.set(2)
await cfg.option('test1').value.set(3)
await cfg.option('test1').value.set(4)
await cfg.option('test2').value.set(2)
await cfg.option('test2').value.set(3)
with pytest.raises(ValueError):
await cfg.option('test2').value.set(4)
assert not await list_sessions()
def test_option_not_in_config():
@pytest.mark.asyncio
async def test_get_display_type():
i1 = IntOption('test1', 'description', min_number=3)
assert i1.get_display_type() == _('integer')
assert not await list_sessions()
@pytest.mark.asyncio
async def test_option_not_in_config():
i1 = IntOption('test1', 'description', min_number=3)
with pytest.raises(AttributeError):
i1.impl_getpath()
# 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(ConfigError):
cfg.option('test1').value.unknown()
def test_option_with_index():
i1 = IntOption('test1', 'description', [4, 5], min_number=3, multi=True)
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(ConfigError):
cfg.option('test1', 0).value.get()
def test_option_display_name():
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,
display_name=display_name,
)
assert cfg.option('test1').name() == 'test1'
assert cfg.option('test1').doc() == 'display_name'
assert not await list_sessions()

2137
tests/test_option_callback.py
View file

File diff suppressed because it is too large Load diff

381
tests/test_option_default.py
View file

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

336
tests/test_option_owner.py
View file

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

1228
tests/test_option_setting.py
View file

File diff suppressed because it is too large Load diff

258
tests/test_option_type.py
View file

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

1872
tests/test_option_validator.py
View file

File diff suppressed because it is too large Load diff

43
tests/test_option_with_special_name.py
View file

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

759
tests/test_permissive.py
View file

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

1844
tests/test_requires.py
View file

File diff suppressed because it is too large Load diff

63
tests/test_slots.py
View file

@ -11,10 +11,13 @@ try:
except:
tiramisu_version = 2
from tiramisu import Config
from tiramisu.config import SubConfig
from tiramisu.option import ChoiceOption, BoolOption, IntOption, FloatOption,\
StrOption, SymLinkOption, StrOption, IPOption, OptionDescription, \
PortOption, NetworkOption, NetmaskOption, DomainnameOption, EmailOption, \
URLOption, FilenameOption
from tiramisu.storage import list_sessions, delete_session
from .config import event_loop
def test_slots_option():
@ -83,7 +86,8 @@ def test_slots_option():
del c
def test_slots_option_readonly():
@pytest.mark.asyncio
async def test_slots_option_readonly():
a = ChoiceOption('a', '', ('a',))
b = BoolOption('b', '')
c = IntOption('c', '')
@ -114,7 +118,8 @@ def test_slots_option_readonly():
o._name = 'o'
p._name = 'p'
q._name = 'q'
Config(m)
async with await Config(m) as cfg:
pass
with pytest.raises(AttributeError):
a._requires = 'a'
with pytest.raises(AttributeError):
@ -145,7 +150,7 @@ def test_slots_option_readonly():
p._requires = 'p'
with pytest.raises(AttributeError):
q._requires = 'q'
# assert not list_sessions()
assert not await list_sessions()
#def test_slots_description():
@ -157,23 +162,47 @@ def test_slots_option_readonly():
# assert slots == set(OptionDescription.__slots__)
def test_slots_setting():
@pytest.mark.asyncio
async def test_slots_config():
od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1])
cfg = Config(od2)
s = cfg._config_bag.context.get_settings()
s
with pytest.raises(AttributeError):
s.x = 1
# assert not list_sessions()
async with await Config(od2) as c:
with pytest.raises(AttributeError):
c._config_bag.context.x = 1
with pytest.raises(AttributeError):
c._config_bag.context.cfgimpl_x = 1
option_bag = OptionBag()
option_bag.set_option(od2,
'a',
ConfigBag(c._config_bag.context, None, None))
sc = await c._config_bag.context.get_subconfig(option_bag)
assert isinstance(sc, SubConfig)
with pytest.raises(AttributeError):
sc.x = 1
with pytest.raises(AttributeError):
sc.cfgimpl_x = 1
assert not await list_sessions()
def test_slots_value():
@pytest.mark.asyncio
async def test_slots_setting():
od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1])
cfg = Config(od2)
v = cfg._config_bag.context.get_values()
v
with pytest.raises(AttributeError):
v.x = 1
# assert not list_sessions()
async with await Config(od2) as c:
s = c._config_bag.context.cfgimpl_get_settings()
s
with pytest.raises(AttributeError):
s.x = 1
assert not await list_sessions()
@pytest.mark.asyncio
async def test_slots_value():
od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1])
async with await Config(od2) as c:
v = c._config_bag.context.cfgimpl_get_values()
v
with pytest.raises(AttributeError):
v.x = 1
assert not await list_sessions()

47
tests/test_state.py Normal file
View file

@ -0,0 +1,47 @@
from .autopath import do_autopath
do_autopath()
from tiramisu import BoolOption, StrOption, SymLinkOption, OptionDescription, DynOptionDescription, \
Calculation, Params, ParamOption, ParamValue, calc_value, Config
from pickle import dumps
import pytest
import sys, warnings
from tiramisu.storage import list_sessions
from .config import event_loop
def test_diff_opt():
b = BoolOption('b', '')
disabled_property = Calculation(calc_value,
Params(ParamValue('disabled'),
kwargs={'condition': ParamOption(b),
'expected': ParamValue(True),
'reverse_condition': ParamValue(True)}))
u = StrOption('u', '', properties=(disabled_property,))
s = SymLinkOption('s', u)
o = OptionDescription('o', '', [b, u, s])
o1 = OptionDescription('o1', '', [o])
with pytest.raises(NotImplementedError):
dumps(o1)
@pytest.mark.asyncio
async def test_diff_information_config():
b = BoolOption('b', '')
b.impl_set_information('info', 'oh')
b.impl_set_information('info1', 'oh')
b.impl_set_information('info2', 'oh')
o = OptionDescription('o', '', [b])
o1 = OptionDescription('o1', '', [o])
async with await Config(o1) as cfg:
c = cfg._config_bag.context
with pytest.raises(NotImplementedError):
dumps(c)
assert not await list_sessions()
def test_only_optiondescription():
b = BoolOption('b', '')
b
with pytest.raises(NotImplementedError):
dumps(b)

333
tests/test_storage.py Normal file
View file

@ -0,0 +1,333 @@
# 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')

812
tests/test_submulti.py
View file

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

529
tests/test_symlink.py
View file

@ -4,11 +4,12 @@ from .autopath import do_autopath
do_autopath()
from .config import config_type, get_config
from tiramisu import BoolOption, StrOption, SymLinkOption, submulti, \
from tiramisu import BoolOption, StrOption, SymLinkOption, \
OptionDescription, Leadership, Config, Calculation, calc_value, Params, ParamOption, ParamValue
from tiramisu.error import PropertiesOptionError, ConfigError
from tiramisu.setting import groups, owners
from tiramisu.i18n import _
from tiramisu.storage import list_sessions
from .config import event_loop
def return_value():
@ -16,173 +17,129 @@ def return_value():
#____________________________________________________________
def test_symlink_option(config_type):
@pytest.mark.asyncio
async def test_symlink_option(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])],
)
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert not cfg.option('s1.b').issymlinkoption()
assert cfg.option('c').issymlinkoption()
assert cfg.option('s1.b').type() == _('boolean')
assert cfg.option('c').type() == _('boolean')
assert cfg.option('s1.b').value.get() is False
cfg.option("s1.b").value.set(True)
cfg.option("s1.b").value.set(False)
assert cfg.option('s1.b').value.get() is False
assert cfg.option('c').value.get() is False
cfg.option('s1.b').value.set(True)
assert cfg.option('s1.b').value.get() is True
assert cfg.option('c').value.get() is True
cfg.option('s1.b').value.set(False)
assert cfg.option('s1.b').value.get() is False
assert cfg.option('c').value.get() is False
# assert not list_sessions()
def test_symlink_default(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])],
)
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert not cfg.option('s1.b').ismulti()
assert not cfg.option('c').ismulti()
assert not cfg.option('s1.b').issubmulti()
assert not cfg.option('c').issubmulti()
assert not cfg.option('s1.b').default()
assert not cfg.option('c').default()
assert not cfg.option('s1.b').value.default()
assert not cfg.option('c').value.default()
with pytest.raises(ConfigError):
assert not cfg.option('s1.b').defaultmulti()
with pytest.raises(ConfigError):
assert not cfg.option('c').defaultmulti()
cfg.option("s1.b").value.set(True)
assert not cfg.option('s1.b').default()
assert not cfg.option('c').default()
assert not cfg.option('s1.b').value.default()
assert not cfg.option('c').value.default()
## assert not list_sessions()
def test_symlink_default_multi(config_type):
boolopt = BoolOption("b", "", default=[False], default_multi=True, multi=True)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])],
)
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('s1.b').ismulti()
assert cfg.option('c').ismulti()
assert not cfg.option('s1.b').issubmulti()
assert not cfg.option('c').issubmulti()
assert cfg.option('s1.b').default() == [False]
assert cfg.option('c').default() == [False]
assert cfg.option('s1.b').value.default() == [False]
assert cfg.option('c').value.default() == [False]
assert cfg.option('s1.b').defaultmulti()
assert cfg.option('c').defaultmulti()
cfg.option("s1.b").value.set([True])
assert cfg.option('s1.b').default() == [False]
assert cfg.option('c').default() == [False]
assert cfg.option('s1.b').value.default() == [False]
assert cfg.option('c').value.default() == [False]
assert cfg.option('s1.b').defaultmulti()
assert cfg.option('c').defaultmulti()
## assert not list_sessions()
def test_symlink_assign_option(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
descr = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
with pytest.raises(ConfigError):
cfg.option('c').value.set(True)
# assert not list_sessions()
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('s1.b').value.get() is False
await cfg.option("s1.b").value.set(True)
await cfg.option("s1.b").value.set(False)
assert await cfg.option('s1.b').value.get() is False
assert await cfg.option('c').value.get() is False
await cfg.option('s1.b').value.set(True)
assert await cfg.option('s1.b').value.get() is True
assert await cfg.option('c').value.get() is True
await cfg.option('s1.b').value.set(False)
assert await cfg.option('s1.b').value.get() is False
assert await cfg.option('c').value.get() is False
assert not await list_sessions()
def test_symlink_del_option(config_type):
@pytest.mark.asyncio
async def test_symlink_assign_option(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
descr = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
with pytest.raises(ConfigError):
cfg.option('c').value.reset()
# assert not list_sessions()
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
with pytest.raises(ConfigError):
await cfg.option('c').value.set(True)
assert not await list_sessions()
def test_symlink_addproperties():
@pytest.mark.asyncio
async def test_symlink_del_option(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
descr = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
with pytest.raises(ConfigError):
await cfg.option('c').value.reset()
assert not await list_sessions()
@pytest.mark.asyncio
async def test_symlink_addproperties():
boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription('opt', '', [boolopt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
with pytest.raises(ConfigError):
cfg.option('c').property.add('new')
with pytest.raises(ConfigError):
cfg.option('c').property.reset()
# assert not list_sessions()
descr = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
with pytest.raises(TypeError):
await cfg.option('c').property.add('new')
try:
await cfg.option('c').property.reset()
except AssertionError:
pass
else:
raise Exception('must raise')
assert not await list_sessions()
def test_symlink_getpermissive():
@pytest.mark.asyncio
async def test_symlink_getpermissive():
boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription('opt', '', [boolopt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
cfg.option('b').permissive.set(frozenset(['perm']))
cfg.option('c').permissive.get() == frozenset(['perm'])
# assert not list_sessions()
descr = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
await cfg.option('b').permissive.set(frozenset(['perm']))
await cfg.option('c').permissive.get() == frozenset(['perm'])
assert not await list_sessions()
def test_symlink_addpermissives():
@pytest.mark.asyncio
async def test_symlink_addpermissives():
boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription('opt', '', [boolopt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
with pytest.raises(ConfigError):
cfg.option('c').permissive.set(frozenset(['new']))
with pytest.raises(ConfigError):
cfg.option('c').permissive.reset()
# assert not list_sessions()
descr = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
with pytest.raises(TypeError):
await cfg.option('c').permissive.set(frozenset(['new']))
try:
await cfg.option('c').permissive.reset()
except AssertionError:
pass
else:
raise Exception('must raise')
assert not await list_sessions()
def test_symlink_getproperties():
@pytest.mark.asyncio
async def test_symlink_getproperties():
boolopt = BoolOption('b', '', default=True, properties=('test',))
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription('opt', '', [boolopt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
assert boolopt.impl_getproperties() == linkopt.impl_getproperties() == {'test'}
# assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False
# assert not list_sessions()
descr = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
assert boolopt.impl_getproperties() == linkopt.impl_getproperties() == {'test'}
assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False
assert not await list_sessions()
def test_symlink_getcallback():
@pytest.mark.asyncio
async def test_symlink_getcallback():
boolopt = BoolOption('b', '', Calculation(return_value))
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription('opt', '', [boolopt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
#assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == True
#assert boolopt.impl_get_callback() == linkopt.impl_get_callback() == (return_value, None)
# assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False
# assert not list_sessions()
descr = OptionDescription('opt', '', [boolopt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
#assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == True
#assert boolopt.impl_get_callback() == linkopt.impl_get_callback() == (return_value, None)
assert boolopt.impl_has_callback() == linkopt.impl_has_callback() == False
assert not await list_sessions()
def test_symlink_requires(config_type):
@pytest.mark.asyncio
async def test_symlink_requires(config_type):
boolopt = BoolOption('b', '', default=True)
disabled_property = Calculation(calc_value,
Params(ParamValue('disabled'),
@ -190,82 +147,86 @@ def test_symlink_requires(config_type):
'expected': ParamValue(False)}))
stropt = StrOption('s', '', properties=(disabled_property,))
linkopt = SymLinkOption("c", stropt)
od1 = OptionDescription('opt', '', [boolopt, stropt, linkopt])
cfg = Config(od1)
cfg.property.read_write()
cfg = get_config(cfg, config_type)
assert cfg.option('b').value.get() is True
assert cfg.option('s').value.get() is None
assert cfg.option('c').value.get() is None
cfg.option('b').value.set(False)
#
props = []
try:
cfg.option('s').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert props == {'disabled'}
#
props = []
try:
cfg.option('c').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert props == {'disabled'}
# assert not list_sessions()
descr = OptionDescription('opt', '', [boolopt, stropt, linkopt])
async with await Config(descr) as cfg:
await cfg.property.read_write()
cfg = await get_config(cfg, config_type)
assert await cfg.option('b').value.get() is True
assert await cfg.option('s').value.get() is None
assert await cfg.option('c').value.get() is None
await cfg.option('b').value.set(False)
#
props = []
try:
await cfg.option('s').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert props == {'disabled'}
#
props = []
try:
await cfg.option('c').value.get()
except PropertiesOptionError as err:
props = err.proptype
assert props == {'disabled'}
assert not await list_sessions()
def test_symlink_multi(config_type):
@pytest.mark.asyncio
async def test_symlink_multi(config_type):
boolopt = BoolOption("b", "", default=[False], multi=True)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
descr = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('s1.b').value.get() == [False]
assert cfg.option('c').value.get() == [False]
cfg.option('s1.b').value.set([True])
assert cfg.option('s1.b').value.get() == [True]
assert cfg.option('c').value.get() == [True]
cfg.option('s1.b').value.set([False])
assert cfg.option('s1.b').value.get() == [False]
assert cfg.option('c').value.get() == [False]
cfg.option('s1.b').value.set([False, True])
assert cfg.option('s1.b').value.get() == [False, True]
assert cfg.option('c').value.get() == [False, True]
assert boolopt.impl_is_multi() is True
assert linkopt.impl_is_multi() is True
# assert not list_sessions()
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('s1.b').value.get() == [False]
assert await cfg.option('c').value.get() == [False]
await cfg.option('s1.b').value.set([True])
assert await cfg.option('s1.b').value.get() == [True]
assert await cfg.option('c').value.get() == [True]
await cfg.option('s1.b').value.set([False])
assert await cfg.option('s1.b').value.get() == [False]
assert await cfg.option('c').value.get() == [False]
await cfg.option('s1.b').value.set([False, True])
assert await cfg.option('s1.b').value.get() == [False, True]
assert await cfg.option('c').value.get() == [False, True]
assert boolopt.impl_is_multi() is True
assert linkopt.impl_is_multi() is True
assert not await list_sessions()
def test_symlink_assign(config_type):
@pytest.mark.asyncio
async def test_symlink_assign(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
descr = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
with pytest.raises(ConfigError):
cfg.option('c').value.set(True)
# assert not list_sessions()
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
with pytest.raises(ConfigError):
await cfg.option('c').value.set(True)
assert not await list_sessions()
def test_symlink_owner(config_type):
@pytest.mark.asyncio
async def test_symlink_owner(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
descr = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.option('s1.b').owner.isdefault()
assert cfg.option('c').owner.isdefault()
cfg.option('s1.b').value.set(True)
assert not cfg.option('s1.b').owner.isdefault()
assert not cfg.option('c').owner.isdefault()
# assert not list_sessions()
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.option('s1.b').owner.isdefault()
assert await cfg.option('c').owner.isdefault()
await cfg.option('s1.b').value.set(True)
assert not await cfg.option('s1.b').owner.isdefault()
assert not await cfg.option('c').owner.isdefault()
assert not await list_sessions()
def test_symlink_get_information():
@pytest.mark.asyncio
async def test_symlink_get_information():
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
boolopt.impl_set_information('test', 'test')
@ -276,7 +237,8 @@ def test_symlink_get_information():
assert linkopt.impl_get_information('test') == 'test2'
def test_symlink_leader():
@pytest.mark.asyncio
async def test_symlink_leader():
a = StrOption('a', "", multi=True)
ip_admin_eth0 = SymLinkOption('ip_admin_eth0', a)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "", multi=True)
@ -284,7 +246,8 @@ def test_symlink_leader():
Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
def test_symlink_followers():
@pytest.mark.asyncio
async def test_symlink_followers():
a = StrOption('a', "", multi=True)
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = SymLinkOption('netmask_admin_eth0', a)
@ -292,117 +255,107 @@ def test_symlink_followers():
Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
def test_symlink_with_leader(config_type):
@pytest.mark.asyncio
async def test_symlink_with_leader(config_type):
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
leader = SymLinkOption('leader', ip_admin_eth0)
od1 = OptionDescription('root', '', [interface1, leader])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'leader': []}
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': 'val1', 'ip_admin_eth0.netmask_admin_eth0': None}, {'ip_admin_eth0.ip_admin_eth0': 'val2', 'ip_admin_eth0.netmask_admin_eth0': None}], 'leader': ['val1', 'val2']}
cfg.option('ip_admin_eth0.ip_admin_eth0').value.pop(0)
with pytest.raises(ConfigError):
cfg.option('leader').value.pop(0)
# assert not list_sessions()
od = OptionDescription('root', '', [interface1, leader])
async with await Config(od) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'leader': []}
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'leader': ['val1', 'val2']}
assert not await list_sessions()
def test_symlink_with_follower(config_type):
@pytest.mark.asyncio
async def test_symlink_with_follower(config_type):
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
follower = SymLinkOption('follower', netmask_admin_eth0)
od1 = OptionDescription('root', '', [interface1, follower])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert not cfg.option('follower').isoptiondescription()
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'follower': []}
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': 'val1', 'ip_admin_eth0.netmask_admin_eth0': None}, {'ip_admin_eth0.ip_admin_eth0': 'val2', 'ip_admin_eth0.netmask_admin_eth0': None}], 'follower': [None, None]}
#
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == 'default'
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).owner.get() == 'default'
with pytest.raises(ConfigError):
assert cfg.option('follower', 0).owner.get() == 'default'
assert cfg.option('follower').owner.get() == 'default'
#
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == None
with pytest.raises(ConfigError):
assert cfg.option('follower', 0).value.get() == None
assert cfg.option('follower').value.get() == [None, None]
#
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('val3')
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [{'ip_admin_eth0.ip_admin_eth0': 'val1', 'ip_admin_eth0.netmask_admin_eth0': None}, {'ip_admin_eth0.ip_admin_eth0': 'val2', 'ip_admin_eth0.netmask_admin_eth0': 'val3'}], 'follower': [None, 'val3']}
#
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == 'val3'
with pytest.raises(ConfigError):
assert cfg.option('follower', 0).value.get() == None
assert cfg.option('follower').value.get() == [None, 'val3']
#
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == 'default'
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).owner.get() == 'user'
with pytest.raises(ConfigError):
assert cfg.option('follower', 0).owner.get() == 'default'
assert cfg.option('follower').owner.get() == 'user'
# assert not list_sessions()
od = OptionDescription('root', '', [interface1, follower])
async with await Config(od) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': [], 'ip_admin_eth0.netmask_admin_eth0': [], 'follower': []}
await cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['val1', 'val2'])
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, None], 'follower': [None, None]}
#
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == 'default'
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).owner.get() == 'default'
assert await cfg.option('follower', 0).owner.get() == 'default'
assert await cfg.option('follower', 1).owner.get() == 'default'
assert await cfg.option('follower').owner.get() == ['default', 'default']
#
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == None
assert await cfg.option('follower', 0).value.get() == None
assert await cfg.option('follower', 1).value.get() == None
assert await cfg.option('follower').value.get() == [None, None]
#
await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('val3')
assert await cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['val1', 'val2'], 'ip_admin_eth0.netmask_admin_eth0': [None, 'val3'], 'follower': [None, 'val3']}
#
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() == None
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == 'val3'
assert await cfg.option('follower', 0).value.get() == None
assert await cfg.option('follower', 1).value.get() == 'val3'
assert await cfg.option('follower').value.get() == [None, 'val3']
#
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).owner.get() == 'default'
assert await cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).owner.get() == 'user'
assert await cfg.option('follower', 0).owner.get() == 'default'
assert await cfg.option('follower', 1).owner.get() == 'user'
assert await cfg.option('follower').owner.get() == ['default', 'user']
assert not await list_sessions()
#____________________________________________________________
def test_symlink_dependency():
@pytest.mark.asyncio
async def test_symlink_dependency():
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
descr = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
cfg = Config(od1)
assert cfg.option('s1.b').has_dependency() is False
assert cfg.option('c').has_dependency() is True
assert cfg.option('s1.b').has_dependency(False) is True
assert cfg.option('c').has_dependency(False) is False
# assert not list_sessions()
async with await Config(descr) as cfg:
assert await cfg.option('s1.b').option.has_dependency() is False
assert await cfg.option('c').option.has_dependency() is True
assert await cfg.option('s1.b').option.has_dependency(False) is True
assert await cfg.option('c').option.has_dependency(False) is False
assert not await list_sessions()
def test_symlink_makedict(config_type):
@pytest.mark.asyncio
async def test_symlink_makedict(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
descr = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
assert cfg.value.dict() == {'c': False, 's1.b': False}
cfg.option('s1.b').value.set(True)
assert cfg.value.dict() == {'c': True, 's1.b': True}
# assert not list_sessions()
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
assert await cfg.value.dict() == {'c': False, 's1.b': False}
await cfg.option('s1.b').value.set(True)
assert await cfg.value.dict() == {'c': True, 's1.b': True}
assert not await list_sessions()
def test_symlink_list(config_type):
@pytest.mark.asyncio
async def test_symlink_list(config_type):
boolopt = BoolOption("b", "", default=False)
linkopt = SymLinkOption("c", boolopt)
od1 = OptionDescription("opt", "",
descr = OptionDescription("opt", "",
[linkopt, OptionDescription("s1", "", [boolopt])])
cfg = Config(od1)
cfg = get_config(cfg, config_type)
list_opt = []
for opt in cfg.option.list():
list_opt.append(opt.path())
assert list_opt == ['c']
#
list_opt = []
for opt in cfg.option.list(recursive=True):
list_opt.append(opt.path())
assert list_opt == ['c', 's1.b']
# assert not list_sessions()
def test_submulti():
multi = StrOption('multi', '', multi=submulti)
multi2 = SymLinkOption('multi2', multi)
od1 = OptionDescription('od', '', [multi, multi2])
cfg = Config(od1)
assert cfg.option('multi').ismulti()
assert cfg.option('multi').issubmulti()
assert cfg.option('multi2').ismulti()
assert cfg.option('multi2').issubmulti()
async with await Config(descr) as cfg:
cfg = await get_config(cfg, config_type)
list_opt = []
for opt in await cfg.option.list():
list_opt.append(await opt.option.path())
assert list_opt == ['c']
#
list_opt = []
for opt in await cfg.option.list(recursive=True):
list_opt.append(await opt.option.path())
assert list_opt == ['c', 's1.b']
assert not await list_sessions()

13
tiramisu/__init__.py
View file

@ -16,14 +16,16 @@
"""
from .function import calc_value, calc_value_property_help, valid_ip_netmask, \
valid_network_netmask, valid_in_network, valid_broadcast, \
valid_not_equal, function_waiting_for_dict
valid_not_equal
from .autolib import Calculation, Params, ParamOption, ParamDynOption, ParamSelfOption, \
ParamValue, ParamIndex, ParamSuffix, ParamInformation, ParamSelfInformation
from .option import *
from .error import ConfigError
from .error import APIError
from .api import Config, MetaConfig, GroupConfig, MixConfig
from .option import __all__ as all_options
from .setting import owners, groups, undefined
from .storage import default_storage, Storage, list_sessions, \
delete_session
allfuncs = ['Calculation',
@ -40,17 +42,20 @@ allfuncs = ['Calculation',
'MixConfig',
'GroupConfig',
'Config',
'ConfigError',
'APIError',
'undefined',
'owners',
'groups',
'default_storage',
'Storage',
'list_sessions',
'delete_session',
'calc_value',
'calc_value_property_help',
'valid_ip_netmask',
'valid_network_netmask',
'valid_in_network',
'valid_broadcast',
'function_waiting_for_dict',
]
allfuncs.extend(all_options)
del(all_options)

2492
tiramisu/api.py
View file

File diff suppressed because it is too large Load diff

29
tiramisu/asyncinit.py Normal file
View file

@ -0,0 +1,29 @@
# -*- 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

524
tiramisu/autolib.py
View file

@ -19,12 +19,12 @@
# ____________________________________________________________
"enables us to carry out a calculation and return an option's value"
from typing import Any, Optional, Union, Callable, Dict, List
from types import CoroutineType
from itertools import chain
from .error import PropertiesOptionError, ConfigError, LeadershipError, ValueWarning
from .i18n import _
from .setting import undefined, ConfigBag, OptionBag, Undefined
from .function import FUNCTION_WAITING_FOR_DICT
# ____________________________________________________________
@ -59,15 +59,15 @@ class Param:
class ParamOption(Param):
__slots__ = ('option',
__slots__ = ('todict',
'option',
'notraisepropertyerror',
'raisepropertyerror',
)
'raisepropertyerror')
def __init__(self,
option: 'Option',
notraisepropertyerror: bool=False,
raisepropertyerror: bool=False,
) -> None:
todict: bool=False) -> None:
if __debug__ and not hasattr(option, 'impl_is_symlinkoption'):
raise ValueError(_('paramoption needs an option not {}').format(type(option)))
if option.impl_is_symlinkoption():
@ -76,36 +76,40 @@ class ParamOption(Param):
cur_opt = option
assert isinstance(notraisepropertyerror, bool), _('param must have a boolean not a {} for notraisepropertyerror').format(type(notraisepropertyerror))
assert isinstance(raisepropertyerror, bool), _('param must have a boolean not a {} for raisepropertyerror').format(type(raisepropertyerror))
self.todict = todict
self.option = cur_opt
self.notraisepropertyerror = notraisepropertyerror
self.raisepropertyerror = raisepropertyerror
class ParamDynOption(ParamOption):
__slots__ = ('subpath',)
__slots__ = ('suffix',)
def __init__(self,
option: 'Option',
subpath: str,
suffix: str,
dynoptiondescription: 'DynOptionDescription',
notraisepropertyerror: bool=False,
raisepropertyerror: bool=False,
optional: bool=False,
todict: bool=False,
) -> None:
super().__init__(option,
notraisepropertyerror,
raisepropertyerror,
todict,
)
self.subpath = subpath
self.suffix = suffix
self.dynoptiondescription = dynoptiondescription
self.optional = optional
class ParamSelfOption(Param):
__slots__ = ('whole')
__slots__ = ('todict', 'whole')
def __init__(self,
whole: bool=undefined,
) -> None:
todict: bool=False,
whole: bool=undefined) -> None:
"""whole: send all value for a multi, not only indexed value"""
self.todict = todict
if whole is not undefined:
self.whole = whole
@ -117,25 +121,13 @@ class ParamValue(Param):
class ParamInformation(Param):
__slots__ = ('information_name',
'default_value',
'option',
)
__slots__ = ('information_name',)
def __init__(self,
information_name: str,
default_value: Any=undefined,
option: 'Option'=None
) -> None:
self.information_name = information_name
self.default_value = default_value
if option:
if option.impl_is_symlinkoption():
raise ValueError(_('option in ParamInformation cannot be a symlinkoption'))
if option.impl_is_follower():
raise ValueError(_('option in ParamInformation cannot be a follower'))
if option.impl_is_dynsymlinkoption():
raise ValueError(_('option in ParamInformation cannot be a dynamic option'))
self.option = option
class ParamSelfInformation(ParamInformation):
@ -155,14 +147,12 @@ class Calculation:
'params',
'help_function',
'_has_index',
'warnings_only',
)
'warnings_only')
def __init__(self,
function: Callable,
params: Params=Params(),
help_function: Optional[Callable]=None,
warnings_only: bool=False,
):
warnings_only: bool=False):
assert isinstance(function, Callable), _('first argument ({0}) must be a function').format(function)
if help_function:
assert isinstance(help_function, Callable), _('help_function ({0}) must be a function').format(help_function)
@ -178,57 +168,74 @@ class Calculation:
if warnings_only is True:
self.warnings_only = warnings_only
def execute(self,
async def execute(self,
option_bag: OptionBag,
leadership_must_have_index: bool=False,
orig_value: Any=undefined,
allow_value_error: bool=False,
force_value_warning: bool=False,
for_settings: bool=False,
) -> Any:
return carry_out_calculation(option_bag.option,
callback=self.function,
callback_params=self.params,
index=option_bag.index,
config_bag=option_bag.config_bag,
orig_value=orig_value,
allow_value_error=allow_value_error,
force_value_warning=force_value_warning,
for_settings=for_settings,
)
return await carry_out_calculation(option_bag.option,
callback=self.function,
callback_params=self.params,
index=option_bag.index,
config_bag=option_bag.config_bag,
leadership_must_have_index=leadership_must_have_index,
orig_value=orig_value,
allow_value_error=allow_value_error,
force_value_warning=force_value_warning,
for_settings=for_settings,
)
def help(self,
option_bag: OptionBag,
for_settings: bool=False,
) -> str:
async def help(self,
option_bag: OptionBag,
leadership_must_have_index: bool=False,
for_settings: bool=False,
) -> str:
if not self.help_function:
return self.execute(option_bag,
for_settings=for_settings,
)
return carry_out_calculation(option_bag.option,
callback=self.help_function,
callback_params=self.params,
index=option_bag.index,
config_bag=option_bag.config_bag,
for_settings=for_settings,
)
return await self.execute(option_bag,
leadership_must_have_index=leadership_must_have_index,
for_settings=for_settings,
)
return await carry_out_calculation(option_bag.option,
callback=self.help_function,
callback_params=self.params,
index=option_bag.index,
config_bag=option_bag.config_bag,
leadership_must_have_index=leadership_must_have_index,
for_settings=for_settings,
)
def __deepcopy__(x, memo):
return x
def has_index(self, current_option):
if hasattr(self, '_has_index'):
return self._has_index
self._has_index = False
for arg in chain(self.params.args, self.params.kwargs.values()):
if isinstance(arg, ParamOption) and arg.option.impl_get_leadership() and \
arg.option.impl_get_leadership().in_same_group(current_option):
self._has_index = True
break
return self._has_index
def manager_callback(callback: Callable,
param: Param,
option,
index: Optional[int],
orig_value,
config_bag: ConfigBag,
for_settings: bool,
) -> Any:
class Break(Exception):
pass
async def manager_callback(callbk: Param,
option,
index: Optional[int],
orig_value,
config_bag: ConfigBag,
leadership_must_have_index: bool,
for_settings: bool,
) -> Any:
"""replace Param by true value"""
def calc_index(param, index, same_leadership):
def calc_index(callbk, index, same_leadership):
if index is not None:
if hasattr(param, 'whole'):
whole = param.whole
if hasattr(callbk, 'whole'):
whole = callbk.whole
else:
# if value is same_leadership, follower are isolate by default
# otherwise option is a whole option
@ -237,32 +244,19 @@ def manager_callback(callback: Callable,
return index
return None
def calc_self(param,
option,
index,
value,
config_bag,
):
async def calc_self(callbk, option, index, value, config_bag):
# index must be apply only if follower
is_follower = option.impl_is_follower()
apply_index = calc_index(param, index, is_follower)
apply_index = calc_index(callbk, index, is_follower)
if value is undefined or (apply_index is None and is_follower):
if config_bag is undefined:
return undefined
path = option.impl_getpath()
option_bag = OptionBag(option,
None,
config_bag,
properties=None,
)
properties = config_bag.context.get_settings().getproperties(option_bag,
uncalculated=True,
)
new_value = get_value(config_bag,
option,
param,
apply_index,
True,
properties,
)
option_bag = await get_option_bag(config_bag,
option,
apply_index,
True)
new_value = await get_value(callbk, option_bag, path)
if apply_index is None and is_follower:
new_value[index] = value
value = new_value
@ -270,70 +264,36 @@ def manager_callback(callback: Callable,
value = value[apply_index]
return value
def get_value(config_bag,
option,
param,
index,
self_calc,
properties=undefined,
):
parent_option_bag, option_bag = get_option_bag(config_bag,
option,
param,
index,
self_calc,
properties=properties,
)
if option.impl_is_follower() and index is None:
value = []
for idx in range(config_bag.context.get_length_leadership(parent_option_bag)):
parent_option_bag, option_bag = get_option_bag(config_bag,
option,
param,
idx,
self_calc,
properties=properties,
)
value.append(_get_value(param,
option_bag,
))
else:
value = _get_value(param,
option_bag,
)
return value
def _get_value(param: Params,
option_bag: OptionBag,
) -> Any:
async def get_value(callbk,
option_bag,
path,
):
try:
# get value
value = config_bag.context.get_value(option_bag)
value = await config_bag.context.getattr(path,
option_bag)
except PropertiesOptionError as err:
# raise PropertiesOptionError (which is catched) because must not add value None in carry_out_calculation
if param.notraisepropertyerror or param.raisepropertyerror:
if callbk.notraisepropertyerror or callbk.raisepropertyerror:
raise err from err
raise ConfigError(_('unable to carry out a calculation for "{}"'
', {}').format(option.impl_get_display_name(), err), err) from err
except ValueError as err:
raise ValueError(_('the option "{0}" is used in a calculation but is invalid ({1})').format(option_bag.option.impl_get_display_name(), err)) from err
except AttributeError as err:
if isinstance(param, ParamDynOption) and param.optional:
if isinstance(callbk, ParamDynOption) and callbk.optional:
# cannot acces, simulate a propertyerror
raise PropertiesOptionError(option_bag,
['configerror'],
config_bag.context.get_settings(),
config_bag.context.cfgimpl_get_settings(),
)
raise ConfigError(_(f'unable to get value for calculating "{option_bag.option.impl_get_display_name()}", {err}')) from err
return value
def get_option_bag(config_bag,
opt,
param,
index_,
self_calc,
properties=undefined,
):
async def get_option_bag(config_bag,
opt,
index_,
self_calc):
# don't validate if option is option that we tried to validate
config_bag = config_bag.copy()
if for_settings:
@ -341,165 +301,103 @@ def manager_callback(callback: Callable,
config_bag.set_permissive()
if not for_settings:
config_bag.properties -= {'warnings'}
if self_calc:
config_bag.unrestraint()
config_bag.remove_validation()
root_option_bag = OptionBag(config_bag.context.get_description(),
None,
config_bag,
)
try:
options_bag = config_bag.context.get_sub_option_bag(root_option_bag,
opt.impl_getpath(),
index_,
validate_properties=not self_calc,
properties=properties,
)
except PropertiesOptionError as err:
# raise PropertiesOptionError (which is catched) because must not add value None in carry_out_calculation
if param.notraisepropertyerror or param.raisepropertyerror:
raise err from err
raise ConfigError(_('unable to carry out a calculation for "{}"'
', {}').format(option.impl_get_display_name(), err), err) from err
except ValueError as err:
raise ValueError(_('the option "{0}" is used in a calculation but is invalid ({1})').format(option.impl_get_display_name(), err)) from err
except AttributeError as err:
if isinstance(param, ParamDynOption) and param.optional:
# cannot acces, simulate a propertyerror
raise PropertiesOptionError(param,
['configerror'],
config_bag.context.get_settings(),
)
raise ConfigError(_(f'unable to get value for calculating "{option.impl_get_display_name()}", {err}')) from err
if len(options_bag) > 1:
parent_option_bag = options_bag[-2]
option_bag = OptionBag()
option_bag.set_option(opt,
index_,
config_bag)
if not self_calc:
option_bag.properties = await config_bag.context.cfgimpl_get_settings().getproperties(option_bag)
else:
parent_option_bag = None
return parent_option_bag, options_bag[-1]
option_bag.config_bag.unrestraint()
option_bag.config_bag.remove_validation()
# if we are in properties calculation, cannot calculated properties
option_bag.properties = await config_bag.context.cfgimpl_get_settings().getproperties(option_bag,
apply_requires=False)
return option_bag
if isinstance(param, ParamValue):
return param.value
if isinstance(callbk, ParamValue):
return callbk.value
if isinstance(param, ParamInformation):
if isinstance(param, ParamSelfInformation):
option_bag = OptionBag(option,
index,
config_bag,
)
elif param.option:
option_bag = OptionBag(param.option,
None,
config_bag,
)
if isinstance(callbk, ParamInformation):
if isinstance(callbk, ParamSelfInformation):
option_bag = OptionBag()
option_bag.set_option(option,
index,
config_bag,
)
else:
option_bag = None
try:
return config_bag.context.get_values().get_information(option_bag,
param.information_name,
param.default_value,
)
return await config_bag.context.impl_get_information(config_bag,
option_bag,
callbk.information_name,
callbk.default_value,
)
except ValueError as err:
raise ConfigError(_('option "{}" cannot be calculated: {}').format(option.impl_get_display_name(),
str(err),
))
if isinstance(param, ParamIndex):
if isinstance(callbk, ParamIndex):
return index
if isinstance(param, ParamSuffix):
if isinstance(callbk, ParamSuffix):
if not option.issubdyn():
raise ConfigError(_('option "{}" is not in a dynoptiondescription').format(option.impl_get_display_name()))
return option.impl_getsuffix()
if isinstance(param, ParamSelfOption):
value = calc_self(param,
option,
index,
orig_value,
config_bag,
)
if callback.__name__ not in FUNCTION_WAITING_FOR_DICT:
if isinstance(callbk, ParamSelfOption):
if leadership_must_have_index and option.impl_is_follower() and index is None:
raise Break()
value = await calc_self(callbk, option, index, orig_value, config_bag)
if not callbk.todict:
return value
return {'name': option.impl_get_display_name(),
'value': value,
}
'value': value}
if isinstance(param, ParamOption):
callbk_option = param.option
if isinstance(callbk, ParamOption):
callbk_option = callbk.option
callbk_options = None
if callbk_option.issubdyn():
found = False
if isinstance(param, ParamDynOption):
od_path = param.dynoptiondescription.impl_getpath()
if "." in od_path:
rootpath = od_path.rsplit('.', 1)[0] + '.'
else:
rootpath = ''
full_path = rootpath + param.subpath
root_option_bag = OptionBag(config_bag.context.get_description(),
None,
config_bag,
)
try:
soptions_bag = config_bag.context.get_sub_option_bag(root_option_bag,
full_path,
#FIXME index?
index=None,
validate_properties=True,
properties=None,
)
except AttributeError as err:
raise ConfigError(_(f'option "{option.impl_get_display_name()}" is not in a dynoptiondescription: {err}'))
callbk_option = soptions_bag[-1].option
if isinstance(callbk, ParamDynOption):
subdyn = callbk.dynoptiondescription
rootpath = subdyn.impl_getpath() + callbk.suffix
suffix = callbk.suffix
callbk_option = callbk_option.to_dynoption(rootpath,
suffix,
subdyn)
found = True
elif option.impl_is_sub_dyn_optiondescription():
if option.getsubdyn() == callbk_option.getsubdyn():
root_path = option.impl_getpath().rsplit('.', 1)[0]
len_path = root_path.count('.')
full_path = root_path + '.' + callbk_option.impl_getpath().split('.', len_path + 1)[-1]
root_option_bag = OptionBag(config_bag.context.get_description(),
None,
config_bag,
)
try:
soptions_bag = config_bag.context.get_sub_option_bag(root_option_bag,
full_path,
#FIXME index?
index=None,
validate_properties=True,
properties=None,
)
except AttributeError as err:
raise ConfigError(_(f'option "{option.impl_get_display_name()}" is not in a dynoptiondescription: {err}'))
callbk_option = soptions_bag[-1].option
found = True
elif option.impl_is_dynsymlinkoption():
rootpath = option.rootpath
call_path = callbk_option.impl_getpath()
if option.opt.issubdyn() and callbk_option.getsubdyn() == option.getsubdyn() or \
not option.opt.issubdyn() and callbk_option.getsubdyn() == option.opt:
if call_path.startswith(option.opt.impl_getpath().rsplit('.', 1)[0]):
# in same dynoption
if len(callbk_option.impl_getpath().split('.')) == len(rootpath.split('.')):
rootpath = rootpath.rsplit('.', 1)[0]
suffix = option.impl_getsuffix()
subdyn = callbk_option.getsubdyn()
root_path, sub_path = subdyn.split_path(subdyn,
option,
)
if root_path:
parent_path = root_path + subdyn.impl_getname(suffix) + sub_path
else:
parent_path = subdyn.impl_getname(suffix) + sub_path
callbk_option = callbk_option.to_dynoption(parent_path,
callbk_option = callbk_option.to_dynoption(rootpath,
suffix,
subdyn,
)
found = True
if not found:
callbk_options = []
for doption_bag in callbk_option.getsubdyn().get_sub_children(callbk_option,
config_bag,
index=None,
):
callbk_options.append(doption_bag.option)
dynopt = callbk_option.getsubdyn()
rootpath = dynopt.impl_getpath()
subpaths = [rootpath] + callbk_option.impl_getpath()[len(rootpath) + 1:].split('.')[:-1]
for suffix in await dynopt.get_suffixes(config_bag):
path_suffix = dynopt.convert_suffix_to_path(suffix)
subpath = '.'.join([subp + path_suffix for subp in subpaths])
doption = callbk_option.to_dynoption(subpath,
suffix,
dynopt)
callbk_options.append(doption)
if leadership_must_have_index and callbk_option.impl_is_follower() and index is None:
raise Break()
if config_bag is undefined:
return undefined
if callbk_options is None:
callbk_options = [callbk_option]
values = None
@ -507,7 +405,7 @@ def manager_callback(callback: Callable,
values = []
for callbk_option in callbk_options:
if index is not None and callbk_option.impl_get_leadership() and \
callbk_option.impl_get_leadership().in_same_leadership(option):
callbk_option.impl_get_leadership().in_same_group(option):
if not callbk_option.impl_is_follower():
# leader
index_ = None
@ -519,36 +417,40 @@ def manager_callback(callback: Callable,
else:
index_ = None
with_index = False
if callbk_option.impl_getpath() == 'od.dodval1.st.boolean':
raise Exception('pfff')
value = get_value(config_bag,
callbk_option,
param,
index_,
False,
)
path = callbk_option.impl_getpath()
option_bag = await get_option_bag(config_bag,
callbk_option,
index_,
False)
value = await get_value(callbk,
option_bag,
path,
)
if with_index:
value = value[index]
if values is not None:
values.append(value)
if values is not None:
value = values
if callback.__name__ not in FUNCTION_WAITING_FOR_DICT:
if not callbk.todict:
return value
return {'name': callbk_option.impl_get_display_name(),
'value': value}
raise ConfigError(_('unknown callback type {} in option {}').format(callbk,
option.impl_get_display_name()))
def carry_out_calculation(option,
callback: Callable,
callback_params: Optional[Params],
index: Optional[int],
config_bag: Optional[ConfigBag],
orig_value=undefined,
allow_value_error: bool=False,
force_value_warning: bool=False,
for_settings: bool=False,
):
async def carry_out_calculation(option,
callback: Callable,
callback_params: Optional[Params],
index: Optional[int],
config_bag: Optional[ConfigBag],
orig_value=undefined,
leadership_must_have_index: bool=False,
allow_value_error: bool=False,
force_value_warning: bool=False,
for_settings: bool=False,
):
"""a function that carries out a calculation for an option's value
:param option: the option
@ -565,42 +467,43 @@ def carry_out_calculation(option,
- tuple with option and boolean's force_permissive (True when don't raise
if PropertiesOptionError)
Values could have multiple values only when key is ''."""
if not option.impl_is_optiondescription() and option.impl_is_follower() and index is None:
raise Exception('follower must have index in carry_out_calculation!')
def fake_items(iterator):
return ((None, i) for i in iterator)
args = []
kwargs = {}
if callback_params:
for key, param 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:
value = manager_callback(callback,
param,
option,
index,
orig_value,
config_bag,
for_settings,
)
value = await manager_callback(callbk,
option,
index,
orig_value,
config_bag,
leadership_must_have_index,
for_settings,
)
if value is undefined:
return undefined
if key is None:
args.append(value)
else:
kwargs[key] = value
except PropertiesOptionError as err:
if param.raisepropertyerror:
if callbk.raisepropertyerror:
raise err
if callback.__name__ in FUNCTION_WAITING_FOR_DICT:
if callbk.todict:
if key is None:
args.append({'propertyerror': str(err), 'name': option.impl_get_display_name()})
args.append({'propertyerror': str(err)})
else:
kwargs[key] = {'propertyerror': str(err), 'name': option.impl_get_display_name()}
ret = calculate(option,
callback,
allow_value_error,
force_value_warning,
args,
kwargs,
)
kwargs[key] = {'propertyerror': str(err)}
except Break:
continue
ret = await calculate(option,
callback,
allow_value_error,
force_value_warning,
args,
kwargs)
if isinstance(ret, list) and not option.impl_is_dynoptiondescription() and \
option.impl_is_follower() and not option.impl_is_submulti():
if args or kwargs:
@ -621,13 +524,13 @@ def carry_out_calculation(option,
return ret
def calculate(option,
callback: Callable,
allow_value_error: bool,
force_value_warning: bool,
args,
kwargs,
):
async def calculate(option,
callback: Callable,
allow_value_error: bool,
force_value_warning: bool,
args,
kwargs,
):
"""wrapper that launches the 'callback'
:param callback: callback function
@ -636,7 +539,10 @@ def calculate(option,
"""
try:
return callback(*args, **kwargs)
ret = callback(*args, **kwargs)
if isinstance(ret, CoroutineType):
ret = await ret
return ret
except (ValueError, ValueWarning) as err:
if allow_value_error:
if force_value_warning:
@ -644,6 +550,8 @@ def calculate(option,
raise err
error = err
except Exception as err:
# import traceback
# traceback.print_exc()
error = err
if args or kwargs:
msg = _('unexpected error "{0}" in function "{1}" with arguments "{3}" and "{4}" '

106
tiramisu/cacheobj.py
View file

@ -1,106 +0,0 @@
# -*- coding: utf-8 -*-
"cache used by storage"
# 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 time import time
class Cache:
"""cache object
"""
__slots__ = ('_cache',)
def __init__(self):
self._cache = {}
def _get_path_index(self, option_bag):
if option_bag is None:
path = None
index = None
else:
path = option_bag.path
index = option_bag.index
return path, index
def getcache(self,
option_bag,
type_,
expiration=True,
):
"""get the cache value fot a specified path
"""
no_cache = False, None, False
path, index = self._get_path_index(option_bag)
if path not in self._cache or index not in self._cache[path]:
return no_cache
value, timestamp, validated = self._cache[path][index]
if type_ == 'context_props':
# cached value is settings properties so value is props
props = value
self_props = {}
else:
props = option_bag.config_bag.properties
if type_ == 'self_props':
# cached value is self_props
self_props = value
else:
self_props = option_bag.properties
if 'cache' in props or \
'cache' in self_props:
if expiration and timestamp and \
('expire' in props or \
'expire' in self_props):
ntime = int(time())
if timestamp + option_bag.config_bag.expiration_time >= ntime:
return True, value, validated
else:
return True, value, validated
return no_cache
def setcache(self,
option_bag,
val,
type_='values',
validated=True,
):
"""add val in cache for a specified path
if follower, add index
"""
if type_ == 'values':
if 'cache' not in option_bag.config_bag.properties and \
'cache' not in option_bag.properties:
return
elif (option_bag is None or 'cache' not in option_bag.config_bag.properties) and \
'cache' not in val:
return
path, index = self._get_path_index(option_bag)
self._cache.setdefault(path, {})[index] = (val, int(time()), validated)
def delcache(self, path):
"""reset cache a a specified path
"""
if path in self._cache:
del self._cache[path]
def get_cached(self):
"""get cache values
"""
return self._cache
def reset_all_cache(self):
"""reset all cache values
"""
self._cache.clear()

2079
tiramisu/config.py
View file

File diff suppressed because it is too large Load diff

9
tiramisu/error.py
View file

@ -128,12 +128,11 @@ class PropertiesOptionError(AttributeError):
# Exceptions for a Config
class ConfigError(Exception):
"""attempt to change an option's owner without a value
or in case of `_descr` is None
or in case of `_cfgimpl_descr` is None
or if a calculation cannot be carried out"""
def __init__(self,
exp,
ori_err=None,
):
ori_err=None):
super().__init__(exp)
self.ori_err = ori_err
@ -210,3 +209,7 @@ class ValueOptionError(_CommonError, ValueError):
class ValueErrorWarning(ValueWarning):
tmpl = _('"{0}" is an invalid {1} for "{2}"')
class APIError(Exception):
pass

479
tiramisu/function.py
View file

@ -12,8 +12,6 @@
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""some functions to validates or calculates value
"""
from typing import Any, List, Optional
from operator import add, mul, sub, truediv
from ipaddress import ip_address, ip_interface, ip_network
@ -22,130 +20,145 @@ from .setting import undefined
from .error import display_list
FUNCTION_WAITING_FOR_DICT = []
def function_waiting_for_dict(function):
"""functions (calculation or validation) receive by default only the value of other options
all functions declared with this function recieve a dict with option informations
(value, name, ...)
def valid_network_netmask(network: str,
netmask: str):
"""FIXME
"""
name = function.__name__
if name not in FUNCTION_WAITING_FOR_DICT:
FUNCTION_WAITING_FOR_DICT.append(name)
return function
@function_waiting_for_dict
def valid_network_netmask(network: dict,
netmask: dict,
):
"""
validates if network and netmask are coherent
this validator must be set to netmask option
"""
if None in [network['value'], netmask['value']]:
if isinstance(network, dict):
network_value = network['value']
network_display_name = '({})'.format(network['name'])
else:
network_value = network
network_display_name = ''
if None in [network_value, netmask]:
return
try:
ip_network(f'{network["value"]}/{netmask["value"]}')
except ValueError as err:
raise ValueError(_(f'network "{network["value"]}" ({network["name"]}) does not match '
'with this netmask')) from err
ip_network('{0}/{1}'.format(network_value, netmask))
except ValueError:
raise ValueError(_('network "{0}" {1}does not match with this netmask').format(network_value,
network_display_name))
@function_waiting_for_dict
def valid_ip_netmask(ip: dict, # pylint: disable=invalid-name
netmask: dict,
):
"""validates if ip and netmask are coherent
this validator must be set to netmask option
"""
if None in [ip['value'], netmask['value']]:
return
ip_netmask = ip_interface(f'{ip["value"]}/{netmask["value"]}')
if ip_netmask.ip == ip_netmask.network.network_address:
msg = _(f'IP "{ip["value"]}" ({ip["name"]}) with this netmask is '
'in fact a network address')
raise ValueError(msg)
if ip_netmask.ip == ip_netmask.network.broadcast_address:
msg = _(f'IP "{ip["value"]}" ({ip["name"]}) with this netmask is '
'in fact a broacast address')
raise ValueError(msg)
@function_waiting_for_dict
def valid_broadcast(network: dict,
netmask: dict,
broadcast: dict,
):
"""validates if the broadcast is coherent with network and netmask
"""
if None in [network['value'], netmask['value'], broadcast['value']]:
return
if ip_network(f'{network["value"]}/{netmask["value"]}').broadcast_address != \
ip_address(broadcast['value']):
msg = _(f'broadcast invalid with network {network["value"]} ({network["name"]}) '
f'and netmask {netmask["value"]} ({netmask["name"]})')
raise ValueError(msg)
@function_waiting_for_dict
def valid_in_network(ip: dict, # pylint: disable=invalid-name
network: dict,
netmask=Optional[dict],
):
"""validates if an IP is in a network
this validator must be set to ip option
"""
if None in [ip['value'], network['value']]:
return
if '/' in network['value']:
# it's a CIDR network
network_value = network['value']
def valid_ip_netmask(ip: str,
netmask: str):
if isinstance(ip, dict):
ip_value = ip['value']
ip_display_name = '({})'.format(ip['name'])
else:
if netmask is None or netmask['value'] is None:
return
network_value = f'{network["value"]}/{netmask["value"]}'
network_obj = ip_network(network_value)
ip_netmask = ip_interface(f'{ip["value"]}/{network_obj.netmask}')
if ip_netmask not in network_obj:
if netmask is None:
msg = _('this IP is not in network {network["value"]} ({network["name"]})')
else:
msg = _('this IP is not in network {network["value"]} ({network["name"]}) '
'with netmask {netmask["value"]} ({netmask["name"]})')
raise ValueError(msg)
# test if ip is not network/broadcast IP
if ip_netmask.ip == ip_netmask.network.network_address:
msg = _(f'this IP with the network {network["value"]} ({network["value"]} '
'is in fact a network address')
raise ValueError(msg)
if ip_netmask.ip == ip_netmask.network.broadcast_address:
msg = _(f'this IP with the network {network["value"]} ({network["value"]} '
'is in fact a broadcast address')
raise ValueError(msg)
@function_waiting_for_dict
def valid_not_equal(*values):
"""valid that two options have not same value
"""
equal = set()
for val in values[1:]:
if 'propertyerror' in val:
continue
if values[0]['value'] == val['value'] is not None:
equal.add(val['name'])
if not equal:
ip_value = ip
ip_display_name = ''
if None in [ip_value, netmask]:
return
msg = _(f'value is identical to {display_list(list(equal), add_quote=True)}')
raise ValueError(msg)
ip_netmask = ip_interface('{0}/{1}'.format(ip_value, netmask))
if ip_netmask.ip == ip_netmask.network.network_address:
raise ValueError(_('IP \"{0}\" {1}with this netmask is in fact a network address').format(ip_value, ip_display_name))
elif ip_netmask.ip == ip_netmask.network.broadcast_address:
raise ValueError(_('IP \"{0}\" {1}with this netmask is in fact a broacast address').format(ip_value, ip_display_name))
# FIXME CIDR ?
def valid_broadcast(network: 'NetworkOption',
netmask: 'NetmaskOption',
broadcast: 'BroadcastOption'):
if isinstance(network, dict):
network_value = network['value']
network_display_name = ' ({})'.format(network['name'])
else:
network_value = network
network_display_name = ''
if isinstance(netmask, dict):
netmask_value = netmask['value']
netmask_display_name = ' ({})'.format(netmask['name'])
else:
netmask_value = netmask
netmask_display_name = ''
if ip_network('{0}/{1}'.format(network, netmask)).broadcast_address != ip_address(broadcast):
raise ValueError(_('broadcast invalid with network {0}{1} and netmask {2}{3}'
'').format(network_value,
network_display_name,
netmask_value,
netmask_display_name))
def valid_in_network(ip,
network,
netmask=None):
if isinstance(network, dict):
network_value = network['value']
network_display_name = ' ({})'.format(network['name'])
else:
network_value = network
network_display_name = ''
if isinstance(netmask, dict):
netmask_value = netmask['value']
netmask_display_name = ' ({})'.format(netmask['name'])
else:
netmask_value = netmask
netmask_display_name = ''
if network_value is None:
return
if '/' in network_value:
network_obj = ip_network('{0}'.format(network_value))
else:
if netmask_value is None:
return
network_obj = ip_network('{0}/{1}'.format(network_value,
netmask_value))
if ip_interface(ip) not in network_obj:
if netmask is None:
msg = _('this IP is not in network {0}{1}').format(network_value,
network_display_name)
else:
msg = _('this IP is not in network {0}{1} with netmask {2}{3}').format(network_value,
network_display_name,
netmask_value,
netmask_display_name)
raise ValueError(msg)
# test if ip is not network/broadcast IP
ip_netmask = ip_interface('{0}/{1}'.format(ip, network_obj.netmask))
if ip_netmask.ip == ip_netmask.network.network_address:
if netmask is None:
msg = _('this IP with the network {0}{1} is in fact a network address').format(network_value,
network_display_name)
else:
msg = _('this IP with the netmask {0}{1} is in fact a network address').format(netmask_value,
netmask_display_name)
raise ValueError(msg)
elif ip_netmask.ip == ip_netmask.network.broadcast_address:
if netmask is None:
msg = _('this IP with the network {0}{1} is in fact a broadcast address').format(network_value,
network_display_name)
else:
msg = _('this IP with the netmask {0}{1} is in fact a broadcast address').format(netmask_value,
netmask_display_name)
raise ValueError(msg)
def valid_not_equal(*values):
equal = set()
for idx, val in enumerate(values[1:]):
if isinstance(val, dict):
if 'propertyerror' in val:
continue
tval = val['value']
else:
tval = val
if values[0] == tval is not None:
if isinstance(val, dict):
if equal is True:
equal = set()
equal.add(val['name'])
elif not equal:
equal = True
if equal:
if equal is not True:
msg = _('value is identical to {}').format(display_list(list(equal), add_quote=True))
else:
msg = _('value is identical')
raise ValueError(msg)
class CalcValue:
"""class to calc_value with different functions
"""
# pylint: disable=too-many-instance-attributes
def __call__(self,
*args: List[Any],
multi: bool=False,
@ -162,7 +175,6 @@ class CalcValue:
operator: Optional[str]=None,
index: Optional[int]=None,
**kwargs) -> Any:
# pylint: disable=too-many-statements,too-many-branches,too-many-nested-blocks,too-many-locals
"""calculate value
:param args: list of value
:param multi: value returns must be a list of value
@ -171,11 +183,9 @@ class CalcValue:
:param condition: test if condition is equal to expected value
if there is more than one condition, set condition_0, condition_1, ...
:param expected: value expected for all conditions
if expected value is different between condition, set expected_0,
expected_1, ...
if expected value is different between condition, set expected_0, expected_1, ...
:param no_condition_is_invalid: if no condition and not condition_0, condition_1, ... (for
example if option is disabled) consider that condition not
matching
example if option is disabled) consider that condition not matching
:param condition_operator: OR or AND operator for condition
:param allow_none: if False, do not return list in None is present in list
:param remove_duplicate_value: if True, remote duplicated value
@ -186,36 +196,28 @@ class CalcValue:
examples:
* you want to copy value from an option to an other option:
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, \
... Params, ParamOption
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, ParamOption
>>> val1 = StrOption('val1', '', 'val1')
>>> val2 = StrOption('val2', '', callback=calc_value,
... callback_params=Params(ParamOption(val1)))
>>> val2 = StrOption('val2', '', callback=calc_value, callback_params=Params(ParamOption(val1)))
>>> od = OptionDescription('root', '', [val1, val2])
>>> cfg = Config(od)
>>> cfg.value.dict()
{'val1': 'val1', 'val2': 'val1'}
* you want to copy values from two options in one multi option
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, \
... ParamOption, ParamValue
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, ParamOption, ParamValue
>>> val1 = StrOption('val1', "", 'val1')
>>> val2 = StrOption('val2', "", 'val2')
>>> val3 = StrOption('val3', "", multi=True, callback=calc_value,
... callback_params=Params((ParamOption(val1), ParamOption(val2)),
... multi=ParamValue(True)))
>>> val3 = StrOption('val3', "", multi=True, callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2)), multi=ParamValue(True)))
>>> od = OptionDescription('root', '', [val1, val2, val3])
>>> cfg = Config(od)
>>> cfg.value.dict()
{'val1': 'val1', 'val2': 'val2', 'val3': ['val1', 'val2']}
* you want to copy a value from an option if it not disabled, otherwise set 'default_value'
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, \
... ParamOption, ParamValue
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, ParamOption, ParamValue
>>> val1 = StrOption('val1', '', 'val1')
>>> val2 = StrOption('val2', '', callback=calc_value,
... callback_params=Params(ParamOption(val1, True),
... default=ParamValue('default_value')))
>>> val2 = StrOption('val2', '', callback=calc_value, callback_params=Params(ParamOption(val1, True), default=ParamValue('default_value')))
>>> od = OptionDescription('root', '', [val1, val2])
>>> cfg = Config(od)
>>> cfg.property.read_write()
@ -226,15 +228,13 @@ class CalcValue:
{'val2': 'default_value'}
* you want to copy value from an option if an other is True, otherwise set 'default_value'
>>> from tiramisu import calc_value, BoolOption, StrOption, OptionDescription, Config, \
... Params, ParamOption, ParamValue
>>> from tiramisu import calc_value, BoolOption, StrOption, OptionDescription, Config, Params, ParamOption, ParamValue
>>> boolean = BoolOption('boolean', '', True)
>>> val1 = StrOption('val1', '', 'val1')
>>> val2 = StrOption('val2', '', callback=calc_value,
... callback_params=Params(ParamOption(val1, True),
... default=ParamValue('default_value'),
... condition=ParamOption(boolean),
... expected=ParamValue(True)))
>>> val2 = StrOption('val2', '', callback=calc_value, callback_params=Params(ParamOption(val1, True),
... default=ParamValue('default_value'),
... condition=ParamOption(boolean),
... expected=ParamValue(True)))
>>> od = OptionDescription('root', '', [boolean, val1, val2])
>>> cfg = Config(od)
>>> cfg.property.read_write()
@ -245,55 +245,41 @@ class CalcValue:
{'boolean': False, 'val1': 'val1', 'val2': 'default_value'}
* you want to copy option even if None is present
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, \
... ParamOption, ParamValue
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, ParamOption, ParamValue
>>> val1 = StrOption('val1', "", 'val1')
>>> val2 = StrOption('val2', "")
>>> val3 = StrOption('val3', "", multi=True, callback=calc_value,
... callback_params=Params((ParamOption(val1), ParamOption(val2)),
... multi=ParamValue(True), allow_none=ParamValue(True)))
>>> val3 = StrOption('val3', "", multi=True, callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2)), multi=ParamValue(True), allow_none=ParamValue(True)))
>>> od = OptionDescription('root', '', [val1, val2, val3])
>>> cfg = Config(od)
>>> cfg.value.dict()
{'val1': 'val1', 'val2': None, 'val3': ['val1', None]}
* you want uniq value
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, \
... ParamOption, ParamValue
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, ParamOption, ParamValue
>>> val1 = StrOption('val1', "", 'val1')
>>> val2 = StrOption('val2', "", 'val1')
>>> val3 = StrOption('val3', "", multi=True, callback=calc_value,
... callback_params=Params((ParamOption(val1), ParamOption(val2)),
... multi=ParamValue(True), remove_duplicate_value=ParamValue(True)))
>>> val3 = StrOption('val3', "", multi=True, callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2)), multi=ParamValue(True), remove_duplicate_value=ParamValue(True)))
>>> od = OptionDescription('root', '', [val1, val2, val3])
>>> cfg = Config(od)
>>> cfg.value.dict()
{'val1': 'val1', 'val2': 'val1', 'val3': ['val1']}
* you want to join two values with '.'
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, \
... ParamOption, ParamValue
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, ParamOption, ParamValue
>>> val1 = StrOption('val1', "", 'val1')
>>> val2 = StrOption('val2', "", 'val2')
>>> val3 = StrOption('val3', "", callback=calc_value,
... callback_params=Params((ParamOption(val1),
... ParamOption(val2)), join=ParamValue('.')))
>>> val3 = StrOption('val3', "", callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2)), join=ParamValue('.')))
>>> od = OptionDescription('root', '', [val1, val2, val3])
>>> cfg = Config(od)
>>> cfg.value.dict()
{'val1': 'val1', 'val2': 'val2', 'val3': 'val1.val2'}
* you want join three values, only if almost three values are set
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, \
... ParamOption, ParamValue
>>> from tiramisu import calc_value, StrOption, OptionDescription, Config, Params, ParamOption, ParamValue
>>> val1 = StrOption('val1', "", 'val1')
>>> val2 = StrOption('val2', "", 'val2')
>>> val3 = StrOption('val3', "", 'val3')
>>> val4 = StrOption('val4', "", callback=calc_value,
... callback_params=Params((ParamOption(val1),
... ParamOption(val2),
... ParamOption(val3, True)),
... join=ParamValue('.'), min_args_len=ParamValue(3)))
>>> val4 = StrOption('val4', "", callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2), ParamOption(val3, True)), join=ParamValue('.'), min_args_len=ParamValue(3)))
>>> od = OptionDescription('root', '', [val1, val2, val3, val4])
>>> cfg = Config(od)
>>> cfg.property.read_write()
@ -304,31 +290,25 @@ class CalcValue:
{'val1': 'val1', 'val2': 'val2', 'val4': ''}
* you want to add all values
>>> from tiramisu import calc_value, IntOption, OptionDescription, Config, Params, \
... ParamOption, ParamValue
>>> from tiramisu import calc_value, IntOption, OptionDescription, Config, Params, ParamOption, ParamValue
>>> val1 = IntOption('val1', "", 1)
>>> val2 = IntOption('val2', "", 2)
>>> val3 = IntOption('val3', "", callback=calc_value,
... callback_params=Params((ParamOption(val1),
ParamOption(val2)),
... operator=ParamValue('add')))
>>> val3 = IntOption('val3', "", callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2)), operator=ParamValue('add')))
>>> od = OptionDescription('root', '', [val1, val2, val3])
>>> cfg = Config(od)
>>> cfg.value.dict()
{'val1': 1, 'val2': 2, 'val3': 3}
"""
# pylint: disable=attribute-defined-outside-init
self.args = args
self.condition = condition
self.expected = expected
self.condition_operator = condition_operator
self.reverse_condition = reverse_condition
self.kwargs = kwargs
self.no_condition_is_invalid = no_condition_is_invalid # pylint: disable=attribute-defined-outside-init
self.no_condition_is_invalid = no_condition_is_invalid
value = self.get_value(default,
min_args_len,
)
min_args_len)
if not multi:
if join is not None:
if None not in value:
@ -337,13 +317,12 @@ class CalcValue:
value = None
elif value and operator:
new_value = value[0]
oper = {'mul': mul,
'add': add,
'div': truediv,
'sub': sub,
}[operator]
op = {'mul': mul,
'add': add,
'div': truediv,
'sub': sub}[operator]
for val in value[1:]:
new_value = oper(new_value, val)
new_value = op(new_value, val)
value = new_value
elif value == []:
value = None
@ -365,9 +344,7 @@ class CalcValue:
break
lval = len(val)
if length_val is not None and length_val != lval:
msg = _('unexpected value in calc_value with join attribute '
f'"{val}" with invalid length "{length_val}"')
raise ValueError(msg)
raise ValueError(_(f'unexpected value in calc_value with join attribute "{val}" with invalid length "{length_val}"'))
length_val = lval
new_value = []
if length_val is not None:
@ -397,9 +374,6 @@ class CalcValue:
pattern: str,
to_dict: bool=False,
empty_test=undefined) -> Any:
"""get value from kwargs
"""
# pylint: disable=too-many-branches
# if value attribute exist return it's value
# otherwise pattern_0, pattern_1, ...
# otherwise undefined
@ -411,9 +385,10 @@ class CalcValue:
else:
kwargs_matches = {}
len_pattern = len(pattern)
for key, pattern_value in self.kwargs.items():
for key in self.kwargs.keys():
if key.startswith(pattern):
index = int(key[len_pattern:])
pattern_value = self.kwargs[key]
if isinstance(pattern_value, dict):
pattern_value = pattern_value['value']
kwargs_matches[index] = pattern_value
@ -433,28 +408,21 @@ class CalcValue:
return returns
def is_condition_matches(self,
condition_value,
):
"""verify the condition
"""
# pylint: disable=too-many-branches
condition_value):
calculated_conditions = self.value_from_kwargs(condition_value,
'condition_',
to_dict='all',
)
to_dict='all')
if calculated_conditions is undefined:
is_matches = not self.no_condition_is_invalid
else:
is_matches = None
calculated_expected = self.value_from_kwargs(self.expected,
'expected_',
to_dict=True,
)
to_dict=True)
calculated_reverse = self.value_from_kwargs(self.reverse_condition,
'reverse_condition_',
to_dict=True,
empty_test=False,
)
empty_test=False)
for idx, calculated_condition in calculated_conditions.items():
if isinstance(calculated_expected, dict):
if idx is not None:
@ -485,20 +453,14 @@ class CalcValue:
if is_matches:
break
else:
msg = _(f'unexpected {self.condition_operator} condition_operator '
'in calc_value')
raise ValueError(msg)
raise ValueError(_('unexpected {} condition_operator in calc_value').format(self.condition_operator))
is_matches = is_matches and not self.reverse_condition \
or not is_matches and self.reverse_condition
return is_matches
def get_value(self,
default,
min_args_len,
):
"""get the value from arguments
"""
# retrieve the condition
min_args_len):
if isinstance(self.condition, dict):
if 'value' in self.condition:
condition_value = self.condition['value']
@ -506,19 +468,18 @@ class CalcValue:
condition_value = undefined
else:
condition_value = self.condition
# value is empty if condition doesn't match
# otherwise value is arg
if not self.is_condition_matches(condition_value):
condition_matches = self.is_condition_matches(condition_value)
if not condition_matches:
# force to default
value = []
else:
value = self.get_args()
if min_args_len and not len(value) >= min_args_len:
value = []
if not value:
if value == []:
# default value
new_default = self.value_from_kwargs(default,
'default_',
)
'default_')
if new_default is not undefined:
if not isinstance(new_default, list):
value = [new_default]
@ -527,34 +488,29 @@ class CalcValue:
return value
def get_args(self):
"""get all arguments
"""
return list(self.args)
class CalcValuePropertyHelp(CalcValue):
"""special class to display property error
"""
def get_name(self):
"""get the condition name
"""
return self.condition['name']
def get_indexed_name(self, index: int) -> str:
"""get name for a specified index
"""
condition_index = self.kwargs.get(f'condition_{index}')
if condition_index is not None and not isinstance(condition_index, dict):
raise ValueError(_(f'unexpected condition_{index} must have "todict" argument'))
return condition_index['name']
def get_indexed_name(self, index):
return self.kwargs.get(f'condition_{index}')['name']
def has_condition_kwargs(self):
for condition in self.kwargs:
if condition.startswith('condition_'):
return True
return False
def build_property_message(self,
name: str,
value: Any,
) -> str:
"""prepare message to display error message if needed
"""
def build_arg(self, name, value):
#if isinstance(option, tuple):
# if not reverse:
# msg = _('the calculated value is {0}').format(display_value)
# else:
# msg = _('the calculated value is not {0}').format(display_value)
#else:
if not self.reverse_condition:
msg = _('the value of "{0}" is {1}').format(name, value)
else:
@ -563,35 +519,40 @@ class CalcValuePropertyHelp(CalcValue):
def get_args(self):
args = super().get_args()
action = args[0]
calculated_expected = self.value_from_kwargs(self.expected,
'expected_',
to_dict=True)
if self.condition is not undefined:
if 'propertyerror' in self.condition:
msg = self.condition['propertyerror']
else:
name = self.get_name()
if isinstance(calculated_expected, dict):
calc_values = calculated_expected.values()
if args:
if len(self.args) != 1:
raise ValueError(_('only one property is allowed for a calculation'))
action = args[0]
calculated_expected = self.value_from_kwargs(self.expected,
'expected_',
to_dict=True)
if self.condition is not undefined:
if 'propertyerror' in self.condition:
msg = self.condition['propertyerror']
else:
calc_values = [calculated_expected]
display_value = display_list([str(val) for val in calc_values],
'or',
add_quote=True)
msg = self.build_property_message(name, display_value)
else:
msgs = []
for key, value in calculated_expected.items():
name = self.get_indexed_name(key)
msgs.append(self.build_property_message(name, f'"{value}"'))
msg = display_list(msgs, self.condition_operator.lower())
return [(action, f'"{action}" ({msg})')]
name = self.get_name()
if isinstance(calculated_expected, dict):
calc_values = calculated_expected.values()
else:
calc_values = [calculated_expected]
display_value = display_list([str(val) for val in calc_values],
'or',
add_quote=True)
msg = self.build_arg(name, display_value)
elif self.has_condition_kwargs():
msgs = []
for key, value in calculated_expected.items():
name = self.get_indexed_name(key)
msgs.append(self.build_arg(name, f'"{value}"'))
msg = display_list(msgs, self.condition_operator.lower())
else:
return [(action, f'"{action}"')]
return [(action, f'"{action}" ({msg})')]
return
## calc_properties.setdefault(action, []).append(msg)
calc_value = CalcValue()
calc_value.__name__ = 'calc_value' # pylint: disable=attribute-defined-outside-init
# function_waiting_for_dict(calc_value)
calc_value.__name__ = 'calc_value'
calc_value_property_help = CalcValuePropertyHelp()
calc_value_property_help.__name__ = 'calc_value_property_help' # pylint: disable=attribute-defined-outside-init
function_waiting_for_dict(calc_value_property_help)
calc_value_property_help.__name__ = 'calc_value_property_help'

10
tiramisu/i18n.py
View file

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

4
tiramisu/locale/fr/LC_MESSAGES/tiramisu.po
View file

@ -277,7 +277,7 @@ msgstr "ne peut accéder à {0} \"{1}\" parce que \"{2}\" a {3} {4}"
#: tiramisu/error.py:116
msgid "cannot access to {0} \"{1}\" because has {2} {3}"
msgstr "ne peut accéder à l'{0} \"{1}\" à cause {2} {3}"
msgstr "ne peut accéder à l'{0} \"{1}\" a cause {2} {3}"
#: tiramisu/error.py:192
msgid "invalid value"
@ -551,7 +551,7 @@ msgstr "ne doit pas être une IP"
#: tiramisu/option/domainnameoption.py:139
msgid "must have dot"
msgstr "doit avoir un point"
msgstr "doit avec un point"
#: tiramisu/option/domainnameoption.py:141
msgid "invalid length (max 255)"

949
tiramisu/locale/tiramisu.pot
View file

File diff suppressed because it is too large Load diff

4
tiramisu/log.py
View file

@ -15,12 +15,12 @@
# 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 logging import getLogger, DEBUG, StreamHandler, Formatter
from logging import getLogger, DEBUG, basicConfig, StreamHandler, Formatter
import os
log = getLogger('tiramisu')
if os.environ.get('TIRAMISU_DEBUG') == 'True': # pragma: no cover
if os.environ.get('TIRAMISU_DEBUG') == 'True':
log.setLevel(DEBUG)
handler = StreamHandler()
handler.setLevel(DEBUG)

22
tiramisu/option/__init__.py
View file

@ -1,25 +1,3 @@
# -*- coding: utf-8 -*-
# Copyright (C) 2014-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/>.
#
# The original `Config` design model is unproudly borrowed from
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""all official option
"""
from .optiondescription import OptionDescription
from .dynoptiondescription import DynOptionDescription
from .syndynoptiondescription import SynDynOptionDescription, SynDynLeadership

212
tiramisu/option/baseoption.py
View file

@ -18,16 +18,18 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""base option
"""
from typing import FrozenSet, Set, Any, List
from types import FunctionType
from typing import FrozenSet, Callable, Tuple, Set, Optional, Union, Any, List
import weakref
from inspect import signature
from itertools import chain
from ..i18n import _
from ..setting import undefined
from ..autolib import Calculation, ParamOption
from ..setting import undefined, Settings
from ..value import Values
from ..error import ConfigError, display_list
from ..autolib import Calculation, Params, ParamOption
STATIC_TUPLE = frozenset()
@ -36,8 +38,6 @@ submulti = 2
def valid_name(name):
"""valid option name
"""
if not isinstance(name, str):
return False
# if '.' in name:
@ -53,7 +53,7 @@ class Base:
__slots__ = ('_name',
'_path',
'_informations',
'_subdyns',
'_subdyn',
'_properties',
'_has_dependency',
'_dependencies',
@ -73,8 +73,7 @@ class Base:
elif isinstance(properties, tuple):
properties = frozenset(properties)
if is_multi:
# if option is a multi, it cannot be 'empty' (None not allowed in the list)
# and cannot have multiple time the same value
# if option is a multi, it cannot be 'empty' (None not allowed in the list) and cannot have multiple time the same value
# 'empty' and 'unique' are removed for follower's option
if 'notunique' not in properties:
properties = properties | {'unique'}
@ -86,8 +85,7 @@ class Base:
for prop in properties:
if not isinstance(prop, str):
if not isinstance(prop, Calculation):
raise ValueError(_('invalid property type {0} for {1}, must be a string or a '
'Calculation').format(type(prop), name))
raise ValueError(_('invalid property type {0} for {1}, must be a string or a Calculation').format(type(prop), name))
for param in chain(prop.params.args, prop.params.kwargs.values()):
if isinstance(param, ParamOption):
param.option._add_dependency(self)
@ -98,21 +96,18 @@ class Base:
_setattr(self, '_properties', properties)
def impl_has_dependency(self,
self_is_dep: bool=True,
) -> bool:
"""this has dependency
"""
self_is_dep: bool=True) -> bool:
if self_is_dep is True:
return getattr(self, '_has_dependency', False)
return hasattr(self, '_dependencies')
def get_dependencies(self,
context_od,
) -> Set[str]:
def _get_dependencies(self,
context_od,
) -> Set[str]:
ret = set(getattr(self, '_dependencies', STATIC_TUPLE))
if context_od and hasattr(context_od, '_dependencies'):
# add options that have context is set in calculation
return set(context_od._dependencies) | ret # pylint: disable=protected-access
return set(context_od._dependencies) | ret
return ret
def _get_suffixes_dependencies(self) -> Set[str]:
@ -123,36 +118,50 @@ class Base:
is_suffix: bool=False,
) -> None:
woption = weakref.ref(option)
options = self.get_dependencies(None)
options.add(woption)
self._dependencies = tuple(options) # pylint: disable=attribute-defined-outside-init
options = self._get_dependencies(None)
options.add(weakref.ref(option))
self._dependencies = tuple(options)
if is_suffix:
options = list(self._get_suffixes_dependencies())
options.append(woption)
self._suffixes_dependencies = tuple(options) # pylint: disable=attribute-defined-outside-init
options.append(weakref.ref(option))
self._suffixes_dependencies = tuple(options)
def _impl_set_callback(self,
callback: Callable,
callback_params: Optional[Params]=None) -> None:
if __debug__:
if callback is None and callback_params is not None:
raise ValueError(_("params defined for a callback function but "
"no callback defined"
' yet for option "{0}"').format(
self.impl_getname()))
self._validate_calculator(callback,
callback_params)
if callback is not None:
callback_params = self._build_calculator_params(callback,
callback_params,
'callback')
# first part is validator
val = getattr(self, '_val_call', (None,))[0]
if not callback_params:
val_call = (callback,)
else:
val_call = (callback, callback_params)
self._val_call = (val, val_call)
def impl_is_optiondescription(self) -> bool:
"""option is an option description
"""
return False
def impl_is_dynoptiondescription(self) -> bool:
"""option is not a dyn option description
"""
return False
def impl_is_sub_dyn_optiondescription(self):
return False
def impl_getname(self) -> str:
"""get name
"""
return self._name # pylint: disable=no-member
return self._name
def _set_readonly(self) -> None:
if isinstance(self._informations, dict): # pylint: disable=no-member
if isinstance(self._informations, dict):
_setattr = object.__setattr__
dico = self._informations # pylint: disable=no-member
dico = self._informations
keys = tuple(dico.keys())
if len(keys) == 1:
dico = dico['doc']
@ -164,36 +173,31 @@ class Base:
_setattr(self, '_extra', tuple([tuple(extra.keys()), tuple(extra.values())]))
def impl_is_readonly(self) -> str:
"""the option is readonly
"""
# _path is None when initialise SymLinkOption
return hasattr(self, '_path') and self._path is not None # pylint: disable=no-member
return hasattr(self, '_path') and self._path is not None
def impl_getproperties(self) -> FrozenSet[str]:
"""get properties
"""
return getattr(self, '_properties', frozenset())
def _setsubdyn(self,
subdyn,
) -> None:
# pylint: disable=attribute-defined-outside-init
if getattr(self, '_subdyns', None) is None:
self._subdyns = []
self._subdyns.append(subdyn)
subdyn) -> None:
self._subdyn = weakref.ref(subdyn)
def issubdyn(self) -> bool:
"""is sub dynoption
"""
return getattr(self, '_subdyns', None) is not None
return getattr(self, '_subdyn', None) is not None
def getsubdyn(self):
"""get sub dynoption
"""
return self._subdyns[0]()
return self._subdyn()
def get_sub_dyns(self):
return self._subdyns
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
@ -205,7 +209,7 @@ class Base:
:param key: the item string (ex: "help")
"""
dico = self._informations # pylint: disable=no-member
dico = self._informations
if isinstance(dico, tuple):
if key in dico[0]:
return dico[1][dico[0].index(key)]
@ -217,9 +221,7 @@ class Base:
return dico[key]
if default is not undefined:
return default
# pylint: disable=no-member
raise ValueError(_(f'information\'s item for "{self.impl_get_display_name()}" '
f'not found: "{key}"'))
raise ValueError(_(f'information\'s item for "{self.impl_get_display_name()}" not found: "{key}"'))
def impl_set_information(self,
key: str,
@ -236,15 +238,13 @@ class Base:
" read-only").format(self.__class__.__name__,
self,
key))
self._informations[key] = value # pylint: disable=no-member
self._informations[key] = value
def impl_list_information(self) -> Any:
"""get the list of information keys
"""
dico = self._informations # pylint: disable=no-member
dico = self._informations
if isinstance(dico, tuple):
return list(dico[0])
if isinstance(dico, str):
elif isinstance(dico, str):
return ['doc']
# it's a dict
return list(dico.keys())
@ -257,10 +257,12 @@ class BaseOption(Base):
"""
__slots__ = ('_display_name_function',)
def __getstate__(self):
raise NotImplementedError()
def __setattr__(self,
name: str,
value: Any,
) -> Any:
value: Any) -> Any:
"""set once and only once some attributes in the option,
like `_name`. `_name` cannot be changed once the option is
pushed in the :class:`tiramisu.option.OptionDescription`.
@ -275,50 +277,68 @@ class BaseOption(Base):
' read-only').format(self.__class__.__name__,
self.impl_get_display_name(),
name))
super().__setattr__(name, value)
super(BaseOption, self).__setattr__(name, value)
def impl_getpath(self) -> str:
"""get the path of the option
"""
try:
return self._path
except AttributeError as err:
raise AttributeError(_(f'"{self.impl_get_display_name()}" not part of any Config')) \
from err
except AttributeError:
raise AttributeError(_('"{}" not part of any Config').format(self.impl_get_display_name()))
def impl_get_display_name(self,
dynopt=None,
) -> str:
"""get display name
"""
if dynopt is None:
dynopt = self
if hasattr(self, '_display_name_function'):
return self._display_name_function(dynopt)
def impl_has_callback(self) -> bool:
"to know if a callback has been defined or not"
return self.impl_get_callback()[0] is not None
def _impl_get_display_name(self,
dyn_name: Base=None,
suffix: str=None,
) -> str:
name = self.impl_get_information('doc', None)
if name is None or name == '':
name = dynopt.impl_getname()
if dyn_name is not None:
name = dyn_name
else:
name = self.impl_getname()
elif suffix:
name += suffix
return name
def _get_display_name(self,
dyn_name,
suffix,
):
if hasattr(self, '_display_name_function'):
return self._display_name_function(self,
dyn_name,
suffix,
)
return self._impl_get_display_name(dyn_name,
suffix,
)
def impl_get_display_name(self) -> str:
return self._get_display_name(None,
None,
)
def reset_cache(self,
path: str,
config_bag: 'OptionBag',
resetted_opts: List[Base], # pylint: disable=unused-argument
) -> None:
"""reset cache
"""
resetted_opts: List[Base]) -> None:
context = config_bag.context
context.properties_cache.delcache(path)
context._impl_permissives_cache.delcache(path) # pylint: disable=protected-access
context._impl_properties_cache.delcache(path)
context._impl_permissives_cache.delcache(path)
if not self.impl_is_optiondescription():
context.get_values_cache().delcache(path) # pylint: disable=protected-access
context._impl_values_cache.delcache(path)
def impl_is_symlinkoption(self) -> bool:
"""the option is not a symlinkoption
"""
return False
def get_dependencies_information(self) -> List[str]:
"""get dependencies information
"""
return getattr(self, '_dependencies_information', {})
def get_dependencies_information(self,
itself=False,
) -> List[str]:
if itself:
idx = 1
else:
idx = 0
return getattr(self, '_dependencies_information', [[], []])[idx]

14
tiramisu/option/booloption.py
View file

@ -18,23 +18,19 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""BoolOption
"""
from ..setting import undefined, Undefined, OptionBag
from ..i18n import _
from .option import Option
class BoolOption(Option):
"""represents a choice between ``True`` and ``False``
"""
"represents a choice between ``True`` and ``False``"
__slots__ = tuple()
_type = _('boolean')
_type = 'boolean'
_display_name = _('boolean')
def validate(self,
value: bool,
) -> None:
"""validate value
"""
value: bool) -> None:
if not isinstance(value, bool):
raise ValueError()

20
tiramisu/option/broadcastoption.py
View file

@ -18,25 +18,21 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""BroadcastOption
"""
from ipaddress import ip_address
from ipaddress import ip_address, ip_network
from ..error import ConfigError
from ..setting import undefined, Undefined, OptionBag
from ..i18n import _
from .option import Option
class BroadcastOption(Option):
"""represents the choice of a broadcast
"""
__slots__ = tuple()
_type = _('broadcast address')
_type = 'broadcast_address'
_display_name = _('broadcast address')
def validate(self,
value: str,
) -> None:
"""validate
"""
value: str) -> None:
if not isinstance(value, str):
raise ValueError(_('invalid string'))
if value.count('.') != 3:
@ -46,5 +42,5 @@ class BroadcastOption(Option):
raise ValueError()
try:
ip_address(value)
except ValueError as err:
raise ValueError() from err
except ValueError:
raise ValueError()

40
tiramisu/option/choiceoption.py
View file

@ -18,8 +18,6 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""ChoiceOption
"""
from typing import Any
from ..setting import undefined, OptionBag
@ -35,7 +33,8 @@ class ChoiceOption(Option):
The option can also have the value ``None``
"""
__slots__ = tuple()
_type = _('choice')
_type = 'choice'
_display_name = _('choice')
def __init__(self,
name,
@ -56,13 +55,10 @@ class ChoiceOption(Option):
*args,
**kwargs)
def impl_get_values(self,
option_bag: OptionBag,
):
"""get values allowed by option
"""
async def impl_get_values(self,
option_bag):
if isinstance(self._choice_values, Calculation):
values = self._choice_values.execute(option_bag)
values = await self._choice_values.execute(option_bag)
if values is not undefined and not isinstance(values, list):
raise ConfigError(_('the calculated values "{0}" for "{1}" is not a list'
'').format(values, self.impl_getname()))
@ -71,27 +67,27 @@ class ChoiceOption(Option):
return values
def validate(self,
value: Any,
) -> None:
"""nothing to valide
"""
value: Any) -> None:
pass
def validate_with_option(self,
value: Any,
option_bag: OptionBag,
loaded: bool,
) -> None:
if loaded and isinstance(self._choice_values, Calculation):
def sync_validate_with_option(self,
value: Any,
option_bag: OptionBag) -> None:
if isinstance(self._choice_values, Calculation):
return
values = self.impl_get_values(option_bag)
values = self._choice_values
self.validate_values(value, values)
async def validate_with_option(self,
value: Any,
option_bag: OptionBag) -> None:
values = await self.impl_get_values(option_bag)
self.validate_values(value, values)
def validate_values(self,
value,
values,
) -> None:
"""validate values
"""
if values is not undefined and value not in values:
if len(values) == 1:
raise ValueError(_('only "{0}" is allowed'

12
tiramisu/option/dateoption.py
View file

@ -18,24 +18,22 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""DateOption
"""
from datetime import datetime
from ..setting import undefined, Undefined, OptionBag
from ..i18n import _
from .stroption import StrOption
class DateOption(StrOption):
"""represents the choice of a date
"""
__slots__ = tuple()
_type = _('date')
_type = 'date'
_display_name = _('date')
def validate(self,
value: str) -> None:
super().validate(value)
try:
datetime.strptime(value, "%Y-%m-%d")
except ValueError as err:
raise ValueError() from err
except ValueError:
raise ValueError()

24
tiramisu/option/domainnameoption.py
View file

@ -18,8 +18,6 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""DomainnameOption
"""
import re
from ipaddress import ip_interface
from typing import Any, Optional, List
@ -40,7 +38,8 @@ class DomainnameOption(StrOption):
fqdn: with tld, not supported yet
"""
__slots__ = tuple()
_type = _('domain name')
_type = 'domainname'
_display_name = _('domain name')
def __init__(self,
name: str,
@ -55,9 +54,8 @@ class DomainnameOption(StrOption):
allow_cidr_network: bool=False,
type: str='domainname',
allow_without_dot: bool=False,
allow_startswith_dot: bool=False,
) -> None:
# pylint: disable=too-many-branches,too-many-locals,too-many-arguments
allow_startswith_dot: bool=False) -> None:
if type not in ['netbios', 'hostname', 'domainname']:
raise ValueError(_('unknown type {0} for hostname').format(type))
extra = {'_dom_type': type}
@ -113,10 +111,11 @@ class DomainnameOption(StrOption):
warnings_only=warnings_only,
extra=extra)
def _get_len(self, type_):
if type_ == 'netbios':
def _get_len(self, type):
if type == 'netbios':
return 15
return 63
else:
return 63
def _validate_domain(self,
value: str) -> None:
@ -197,12 +196,15 @@ class DomainnameOption(StrOption):
allow_ip = self.impl_get_extra('_allow_ip')
allow_cidr_network = self.impl_get_extra('_allow_cidr_network')
# it's an IP so validate with IPOption
if allow_ip is True and allow_cidr_network is False:
if allow_ip is False and allow_cidr_network is False:
raise ValueError(_('must not be an IP'))
if allow_ip is True:
try:
self.impl_get_extra('_ip').second_level_validation(value, warnings_only)
return
except ValueError as err:
raise err
if allow_cidr_network is False:
raise err
if allow_cidr_network is True:
self.impl_get_extra('_network').second_level_validation(value, warnings_only)

147
tiramisu/option/dynoptiondescription.py
View file

@ -18,20 +18,16 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""DynOptionDescription
"""
import re
import weakref
from typing import List, Any, Optional, Tuple
from typing import List, Callable, Any
from itertools import chain
from ..autolib import ParamOption
from ..i18n import _
from .optiondescription import OptionDescription
from .syndynoptiondescription import SynDynLeadership
from .baseoption import BaseOption
from ..setting import OptionBag, ConfigBag, undefined
from ..setting import OptionBag, ConfigBag, groups, undefined
from ..error import ConfigError
from ..autolib import Calculation
@ -40,29 +36,31 @@ NAME_REGEXP = re.compile(r'^[a-zA-Z\d\-_]*$')
class DynOptionDescription(OptionDescription):
"""dyn option description
"""
__slots__ = ('_suffixes',
'_subdyns',
)
__slots__ = ('_suffixes',)
def __init__(self,
name: str,
doc: str,
children: List[BaseOption],
suffixes: Calculation,
properties=None,
) -> None:
# pylint: disable=too-many-arguments
properties=None) -> None:
super().__init__(name,
doc,
children,
properties,
)
properties)
# check children + set relation to this dynoptiondescription
wself = weakref.ref(self)
for child in children:
child._setsubdyn(wself)
if isinstance(child, OptionDescription):
if __debug__ and child.impl_get_group_type() != groups.leadership:
raise ConfigError(_('cannot set optiondescription in a '
'dynoptiondescription'))
for chld in child._children[1]:
chld._setsubdyn(self)
if __debug__ and child.impl_is_symlinkoption():
raise ConfigError(_('cannot set symlinkoption in a '
'dynoptiondescription'))
child._setsubdyn(self)
# add suffixes
if __debug__ and not isinstance(suffixes, Calculation):
raise ConfigError(_('suffixes in dynoptiondescription has to be a calculation'))
@ -76,8 +74,6 @@ class DynOptionDescription(OptionDescription):
def convert_suffix_to_path(self,
suffix: Any,
) -> str:
"""convert suffix to use it to a path
"""
if suffix is None:
return None
if not isinstance(suffix, str):
@ -86,30 +82,20 @@ class DynOptionDescription(OptionDescription):
suffix = suffix.replace('.', '_')
return suffix
def get_suffixes(self,
config_bag: ConfigBag,
dynoption=None,
) -> List[str]:
"""get dynamic suffixes
"""
if dynoption:
self_opt = dynoption
else:
self_opt = self
option_bag = OptionBag(self_opt,
None,
config_bag,
properties=None,
)
values = self._suffixes.execute(option_bag)
async def get_suffixes(self,
config_bag: ConfigBag) -> List[str]:
option_bag = OptionBag()
option_bag.set_option(self,
None,
config_bag)
values = await self._suffixes.execute(option_bag)
if values is None:
values = []
values_ = []
if __debug__:
if not isinstance(values, list):
raise ValueError(_('DynOptionDescription suffixes for '
f'option "{self.impl_get_display_name()}", is not '
f'a list ({values})'))
raise ValueError(_('DynOptionDescription suffixes for option "{}", is not a list ({})'
'').format(self.impl_get_display_name(), values))
for val in values:
cval = self.convert_suffix_to_path(val)
if not isinstance(cval, str) or re.match(NAME_REGEXP, cval) is None:
@ -119,83 +105,14 @@ class DynOptionDescription(OptionDescription):
self.impl_get_display_name()))
else:
values_.append(val)
if __debug__ and len(values_) > len(set(values_)):
raise ValueError(_(f'DynOptionDescription "{self._name}" suffixes return a list with '
f'same values "{values_}"'''))
if __debug__:
if len(values_) > len(set(values_)):
extra_values = values_.copy()
for val in set(values_):
extra_values.remove(val)
raise ValueError(_('DynOptionDescription suffixes return a list with multiple value '
'"{}"''').format(extra_values))
return values_
def impl_is_dynoptiondescription(self) -> bool:
return True
def option_is_self(self,
option,
) -> bool:
return option == self or \
(option.impl_is_sub_dyn_optiondescription() and option.opt == self)
def split_path(self,
dynoption,
option,
) -> Tuple[str, str]:
"""self.impl_getpath() is something like root.xxx.dynoption_path
option.impl_getpath() is something like root.xxx.dynoption_path.sub.path
must return ('root.xxx.', '.sub')
"""
if dynoption is None:
self_path = self.impl_getpath()
else:
self_path = dynoption.impl_getpath()
root_path = self_path.rsplit('.', 1)[0] if '.' in self_path else None
#
if self.option_is_self(option):
sub_path = ''
else:
option_path = option.impl_getpath()
if root_path:
if isinstance(option, SynDynLeadership):
count_root_path = option_path.count('.') - root_path.count('.')
root_path = option_path.rsplit('.', count_root_path)[0]
root_path += '.'
self_number_child = self_path.count('.') + 1
option_sub_path = option_path.split('.', self_number_child)[-1]
sub_path = '.' + option_sub_path.rsplit('.', 1)[0] if '.' in option_sub_path else ''
return root_path, sub_path
def get_sub_children(self,
option,
config_bag,
*,
index=None,
properties=undefined,
dynoption=None,
):
root_path, sub_path = self.split_path(dynoption,
option,
)
for suffix in self.get_suffixes(config_bag,
dynoption=dynoption,
):
if self.option_is_self(option):
parent_path = root_path
elif root_path:
parent_path = root_path + self.impl_getname(suffix) + sub_path
else:
parent_path = self.impl_getname(suffix) + sub_path
yield OptionBag(option.to_dynoption(parent_path,
suffix,
self,
),
index,
config_bag,
properties=properties,
ori_option=option
)
def impl_getname(self, suffix=None) -> str:
"""get name
"""
name = super().impl_getname()
if suffix is None:
return name
path_suffix = self.convert_suffix_to_path(suffix)
return name + path_suffix

7
tiramisu/option/emailoption.py
View file

@ -18,8 +18,6 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""EmailOption
"""
import re
from ..i18n import _
@ -27,8 +25,7 @@ from .stroption import RegexpOption
class EmailOption(RegexpOption):
"""represents a choice of an email
"""
__slots__ = tuple()
_regexp = re.compile(r"^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$")
_type = _('email address')
_type = 'email'
_display_name = _('email address')

9
tiramisu/option/filenameoption.py
View file

@ -18,17 +18,16 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""FilenameOption
"""
import re
from ..i18n import _
from .stroption import StrOption
class FilenameOption(StrOption):
"""represents a choice of a file name
"""
__slots__ = tuple()
_type = _('file name')
_type = 'filename'
_display_name = _('file name')
def validate(self,
value: str,

9
tiramisu/option/floatoption.py
View file

@ -18,18 +18,17 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""FloatOption
"""
from ..setting import undefined, Undefined, OptionBag
from ..i18n import _
from .option import Option
class FloatOption(Option):
"""represents a choice of a floating point number
"""
"represents a choice of a floating point number"
__slots__ = tuple()
_type = _('float')
_type = 'float'
_display_name = _('float')
def validate(self,
value: float) -> None:

9
tiramisu/option/intoption.py
View file

@ -18,9 +18,8 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""IntOption
"""
from ..setting import undefined, Undefined, OptionBag
from ..i18n import _
from .option import Option
@ -28,7 +27,8 @@ from .option import Option
class IntOption(Option):
"represents a choice of an integer"
__slots__ = tuple()
_type = _('integer')
_type = 'integer'
_display_name = _('integer')
def __init__(self,
*args,
@ -43,8 +43,7 @@ class IntOption(Option):
super().__init__(*args, extra=extra, **kwargs)
def validate(self,
value: int,
) -> None:
value: int) -> None:
if not isinstance(value, int):
raise ValueError()

36
tiramisu/option/ipoption.py
View file

@ -18,19 +18,21 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""IPOption
"""
from ipaddress import ip_address, ip_interface
from ..error import ConfigError
from ..setting import undefined, Undefined, OptionBag
from ..i18n import _
from .option import Option
from .stroption import StrOption
from ..function import valid_ip_netmask
class IPOption(StrOption):
"""represents the choice of an ip
"""
"represents the choice of an ip"
__slots__ = tuple()
_type = _('IP')
_type = 'ip'
_display_name = _('IP')
def __init__(self,
*args,
@ -50,19 +52,21 @@ class IPOption(StrOption):
def _validate_cidr(self, value):
try:
ip_obj = ip_interface(value)
except ValueError as err:
raise ValueError() from err
if ip_obj.ip == ip_obj.network.network_address:
ip = ip_interface(value)
except ValueError:
raise ValueError()
if ip.ip == ip.network.network_address:
raise ValueError(_("it's in fact a network address"))
if ip_obj.ip == ip_obj.network.broadcast_address:
elif ip.ip == ip.network.broadcast_address:
raise ValueError(_("it's in fact a broacast address"))
def _validate_ip(self, value):
try:
str(ip_address(value))
except ValueError as err:
raise ValueError() from err
new_value = str(ip_address(value))
if value != new_value:
raise ValueError(_(f'should be {new_value}'))
except ValueError:
raise ValueError()
def validate(self,
value: str) -> None:
@ -77,14 +81,14 @@ class IPOption(StrOption):
def second_level_validation(self,
value: str,
warnings_only: bool) -> None:
ip_obj = ip_interface(value)
if not self.impl_get_extra('_allow_reserved') and ip_obj.is_reserved:
ip = ip_interface(value)
if not self.impl_get_extra('_allow_reserved') and ip.is_reserved:
if warnings_only:
msg = _("shouldn't be reserved IP")
else:
msg = _("mustn't be reserved IP")
raise ValueError(msg)
if self.impl_get_extra('_private_only') and not ip_obj.is_private:
if self.impl_get_extra('_private_only') and not ip.is_private:
if warnings_only:
msg = _("should be private IP")
else:

252
tiramisu/option/leadership.py
View file

@ -20,26 +20,24 @@
# the whole pypy projet is under MIT licence
# ____________________________________________________________
import weakref
from typing import List, Iterator, Optional
from itertools import chain
from typing import List, Iterator, Optional, Any
from ..i18n import _
from ..setting import groups, undefined, OptionBag, ALLOWED_LEADER_PROPERTIES
from ..setting import groups, undefined, OptionBag, Settings, ALLOWED_LEADER_PROPERTIES
from ..value import Values
from .optiondescription import OptionDescription
from .syndynoptiondescription import SynDynLeadership
from .baseoption import BaseOption
from .option import Option
from ..error import LeadershipError
from ..autolib import Calculation
from ..autolib import Calculation, ParamOption
class Leadership(OptionDescription):
"""Leadership
"""
# pylint: disable=too-many-arguments
__slots__ = ('leader',
'followers',
)
'followers')
def __init__(self,
name: str,
@ -58,190 +56,182 @@ class Leadership(OptionDescription):
leader = children[0]
for idx, child in enumerate(children):
if __debug__:
self._check_child_is_valid(child)
if child.impl_is_symlinkoption():
raise ValueError(_('leadership "{0}" shall not have '
"a symlinkoption").format(self.impl_get_display_name()))
if not isinstance(child, Option):
raise ValueError(_('leadership "{0}" shall not have '
'a subgroup').format(self.impl_get_display_name()))
if not child.impl_is_multi():
raise ValueError(_('only multi option allowed in leadership "{0}" but option '
'"{1}" is not a multi'
'').format(self.impl_get_display_name(),
child.impl_get_display_name()))
if idx != 0:
default = child.impl_getdefault()
if default != []:
if child.impl_is_submulti() and isinstance(default, tuple):
for val in default:
if not isinstance(val, Calculation):
calculation = False
else:
# empty default is valid
calculation = True
else:
calculation = isinstance(default, Calculation)
if not calculation:
raise ValueError(_('not allowed default value for follower option "{0}" '
'in leadership "{1}"'
'').format(child.impl_get_display_name(),
self.impl_get_display_name()))
if idx != 0:
if __debug__:
self._check_default_value(child)
# remove empty property for follower
child._properties = frozenset(child._properties - {'empty', 'unique'})
followers.append(child)
child._add_dependency(self)
child._leadership = weakref.ref(self)
if __debug__:
callback, callback_params = leader.impl_get_callback()
options = []
if callback is not None and callback_params is not None:
for callbk in chain(callback_params.args, callback_params.kwargs.values()):
if isinstance(callbk, ParamOption) and callbk.option in followers:
raise ValueError(_("callback of leader's option shall "
"not refered to a follower's ones"))
for prop in leader.impl_getproperties():
if prop not in ALLOWED_LEADER_PROPERTIES and not isinstance(prop, Calculation):
raise LeadershipError(_('leader cannot have "{}" property').format(prop))
def _check_child_is_valid(self, child: BaseOption):
if child.impl_is_symlinkoption():
raise ValueError(_('leadership "{0}" shall not have '
"a symlinkoption").format(self.impl_get_display_name()))
if not isinstance(child, Option):
raise ValueError(_('leadership "{0}" shall not have '
'a subgroup').format(self.impl_get_display_name()))
if not child.impl_is_multi():
raise ValueError(_('only multi option allowed in leadership "{0}" but option '
'"{1}" is not a multi'
'').format(self.impl_get_display_name(),
child.impl_get_display_name()))
def _check_default_value(self, child: BaseOption):
default = child.impl_getdefault()
if default != []:
if child.impl_is_submulti() and isinstance(default, (list, tuple)):
for val in default:
if not isinstance(val, Calculation):
calculation = False
break
else:
# empty default is valid
calculation = True
else:
calculation = isinstance(default, Calculation)
if not calculation:
raise ValueError(_('not allowed default value for follower option '
f'"{child.impl_get_display_name()}" in leadership '
f'"{self.impl_get_display_name()}"'))
def _setsubdyn(self,
subdyn,
) -> None:
for chld in self._children[1]:
chld._setsubdyn(subdyn)
super()._setsubdyn(subdyn)
def is_leader(self,
opt: Option,
) -> bool:
"""the option is the leader
"""
opt: Option) -> bool:
leader = self.get_leader()
return opt == leader or (opt.impl_is_dynsymlinkoption() and opt.opt == leader)
def get_leader(self) -> Option:
"""get leader
"""
return self._children[1][0]
def get_followers(self) -> Iterator[Option]:
"""get all followers
"""
for follower in self._children[1][1:]:
yield follower
def in_same_leadership(self,
opt: Option,
) -> bool:
"""check if followers are in same leadership
"""
def in_same_group(self,
opt: Option) -> bool:
if opt.impl_is_dynsymlinkoption():
opt = opt.opt
return opt in self._children[1]
def reset(self, config_bag: 'ConfigBag') -> None:
"""reset follower value
"""
values = config_bag.context.get_values()
config_bag = config_bag.copy()
async def reset(self,
values: Values,
option_bag: OptionBag) -> None:
config_bag = option_bag.config_bag.copy()
config_bag.remove_validation()
for follower in self.get_followers():
soption_bag = OptionBag(follower,
None,
config_bag,
)
values.reset(soption_bag)
soption_bag = OptionBag()
soption_bag.set_option(follower,
None,
config_bag)
soption_bag.properties = await config_bag.context.cfgimpl_get_settings().getproperties(soption_bag)
await values.reset(soption_bag)
def follower_force_store_value(self,
value,
config_bag: 'ConfigBag',
owner,
dyn=None,
) -> None:
"""apply force_store_value to follower
"""
async def follower_force_store_value(self,
values,
value,
option_bag,
owner,
dyn=None,
) -> None:
settings = option_bag.config_bag.context.cfgimpl_get_settings()
if value:
if dyn is None:
dyn = self
values = config_bag.context.get_values()
for idx, follower in enumerate(dyn.get_children(config_bag)):
if not idx:
# it's a master
apply_requires = True
indexes = [None]
else:
apply_requires = False
indexes = range(len(value))
foption_bag = OptionBag(follower,
None,
config_bag,
apply_requires=apply_requires,
)
if 'force_store_value' not in foption_bag.properties:
continue
for index in indexes:
foption_bag_index = OptionBag(follower,
for idx, follower in enumerate(await dyn.get_children(option_bag.config_bag)):
foption_bag = OptionBag()
foption_bag.set_option(follower,
None,
option_bag.config_bag)
if 'force_store_value' in await settings.getproperties(foption_bag):
if idx == 0:
indexes = [None]
else:
indexes = range(len(value))
for index in indexes:
foption_bag = OptionBag()
foption_bag.set_option(follower,
index,
option_bag.config_bag)
foption_bag.properties = await settings.getproperties(foption_bag)
await values._p_.setvalue(foption_bag.config_bag.connection,
foption_bag.path,
await values.getvalue(foption_bag),
owner,
index,
config_bag,
)
values.set_storage_value(foption_bag_index.path,
index,
values.get_value(foption_bag_index)[0],
owner,
)
def pop(self,
index: int,
config_bag: 'ConfigBag',
followers: Optional[List[Option]]=undefined,
) -> None:
"""pop leader value and follower's one
"""
async def pop(self,
values: Values,
index: int,
option_bag: OptionBag,
followers: Optional[List[Option]]=undefined) -> None:
if followers is undefined:
# followers are not undefined only in SynDynLeadership
followers = self.get_followers()
config_bag = config_bag.copy()
config_bag = option_bag.config_bag.copy()
config_bag.remove_validation()
values = config_bag.context.get_values()
for follower in followers:
soption_bag = OptionBag(follower,
index,
config_bag,
properties=set(), # do not check force_default_on_freeze
# or force_metaconfig_on_freeze
)
values.reduce_index(soption_bag)
follower_path = follower.impl_getpath()
followerlen = await values._p_.get_max_length(config_bag.connection,
follower_path)
soption_bag = OptionBag()
soption_bag.set_option(follower,
index,
config_bag)
# do not check force_default_on_freeze or force_metaconfig_on_freeze
soption_bag.properties = set()
is_default = await values.is_default_owner(soption_bag,
validate_meta=False)
if not is_default and followerlen > index:
await values._p_.resetvalue_index(config_bag.connection,
follower_path,
index)
if followerlen > index + 1:
for idx in range(index + 1, followerlen):
if await values._p_.hasvalue(config_bag.connection,
follower_path,
idx):
await values._p_.reduce_index(config_bag.connection,
follower_path,
idx)
def reset_cache(self,
path: str,
config_bag: 'ConfigBag',
resetted_opts: List[Option],
) -> None:
resetted_opts: List[Option]) -> None:
self._reset_cache(path,
self.get_leader(),
self.get_followers(),
config_bag,
resetted_opts,
)
resetted_opts)
def _reset_cache(self,
path: str,
leader: Option,
followers: List[Option],
config_bag: 'ConfigBag',
resetted_opts: List[Option],
) -> None:
resetted_opts: List[Option]) -> None:
super().reset_cache(path,
config_bag,
resetted_opts,
)
resetted_opts)
leader.reset_cache(leader.impl_getpath(),
config_bag,
None)
for follower in followers:
follower.reset_cache(follower.impl_getpath(),
spath = follower.impl_getpath()
follower.reset_cache(spath,
config_bag,
None,
)
None)
# do not reset dependencies option
# resetted_opts.append(spath)
def impl_is_leadership(self) -> None:
return True

7
tiramisu/option/macoption.py
View file

@ -18,8 +18,6 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""MACOption
"""
import re
from ..i18n import _
@ -27,8 +25,7 @@ from .stroption import RegexpOption
class MACOption(RegexpOption):
"""represents the choice of a mac address
"""
__slots__ = tuple()
_regexp = re.compile(r"^([0-9A-Fa-f]{2}[:]){5}([0-9A-Fa-f]{2})$")
_type = _('mac address')
_type = 'macaddress'
_display_name = _('mac address')

21
tiramisu/option/netmaskoption.py
View file

@ -18,18 +18,21 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""NetmaskOption
"""
from ipaddress import ip_network
from ipaddress import ip_interface, ip_network
from typing import List
from ..error import ConfigError
from ..setting import undefined, OptionBag, Undefined
from ..i18n import _
from .option import Option
from .stroption import StrOption
class NetmaskOption(StrOption):
"""represents the choice of a netmask
"""
"represents the choice of a netmask"
__slots__ = tuple()
_type = _('netmask address')
_type = 'netmask'
_display_name = _('netmask address')
def validate(self,
value: str) -> None:
@ -38,6 +41,6 @@ class NetmaskOption(StrOption):
if val.startswith("0") and len(val) > 1:
raise ValueError()
try:
ip_network(f'0.0.0.0/{value}')
except ValueError as err:
raise ValueError() from err
ip_network('0.0.0.0/{0}'.format(value))
except ValueError:
raise ValueError()

11
tiramisu/option/networkoption.py
View file

@ -18,9 +18,7 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""NetworkOption
"""
from ipaddress import ip_network
from ipaddress import ip_address, ip_network
from ..i18n import _
from .stroption import StrOption
@ -29,7 +27,8 @@ from .stroption import StrOption
class NetworkOption(StrOption):
"represents the choice of a network"
__slots__ = tuple()
_type = _('network address')
_type = 'network'
_display_name = _('network address')
def __init__(self,
*args,
@ -57,8 +56,8 @@ class NetworkOption(StrOption):
raise ValueError()
try:
ip_network(value)
except ValueError as err:
raise ValueError() from err
except ValueError:
raise ValueError()
def second_level_validation(self,
value: str,

371
tiramisu/option/option.py
View file

@ -20,19 +20,21 @@
# the whole pypy projet is under MIT licence
# ____________________________________________________________
import warnings
from typing import Any, List, Optional, Dict
import weakref
from typing import Any, List, Callable, Optional, Dict, Union, Tuple
from itertools import chain
from .baseoption import BaseOption, submulti
from .baseoption import BaseOption, submulti, STATIC_TUPLE
from ..i18n import _
from ..setting import undefined, OptionBag
from ..autolib import Calculation, ParamOption, ParamInformation, ParamSelfInformation
from ..error import ValueWarning, ValueErrorWarning, ValueOptionError
from ..setting import undefined, OptionBag, Undefined
from ..autolib import Calculation, Params, ParamOption, ParamInformation, ParamSelfInformation
from ..error import (ConfigError, ValueWarning, ValueErrorWarning,
ValueOptionError, display_list)
from .syndynoption import SynDynOption
#ALLOWED_CONST_LIST = ['_cons_not_equal']
class Option(BaseOption):
# pylint: disable=too-many-statements,too-many-branches,too-many-arguments,too-many-locals
"""
Abstract base class for configuration option's.
@ -53,7 +55,7 @@ class Option(BaseOption):
'_choice_values',
'_choice_values_params',
)
_type = None
_empty = ''
def __init__(self,
name: str,
doc: str,
@ -65,6 +67,7 @@ class Option(BaseOption):
warnings_only: bool=False,
extra: Optional[Dict]=None):
_setattr = object.__setattr__
_dependencies_information = [[], []]
if not multi and default_multi is not None:
raise ValueError(_("default_multi is set whereas multi is False"
" in option: {0}").format(name))
@ -96,11 +99,19 @@ class Option(BaseOption):
is_multi=is_multi)
if validators is not None:
if __debug__ and not isinstance(validators, list):
raise ValueError(_(f'validators must be a list of Calculation for "{name}"'))
raise ValueError(_('validators must be a list of Calculation for "{}"').format(name))
for validator in validators:
if __debug__ and not isinstance(validator, Calculation):
raise ValueError(_('validators must be a Calculation for "{}"').format(name))
self.value_dependency(validator)
for param in chain(validator.params.args, validator.params.kwargs.values()):
if isinstance(param, ParamOption):
param.option._add_dependency(self)
self._has_dependency = True
elif isinstance(param, ParamSelfInformation):
_dependencies_information[1].append(param.information_name)
elif isinstance(param, ParamInformation):
_dependencies_information[0].append(param.information_name)
self._validators = tuple(validators)
if extra is not None and extra != {}:
_setattr(self, '_extra', extra)
@ -110,27 +121,25 @@ class Option(BaseOption):
def test_multi_value(value):
if isinstance(value, Calculation):
return
option_bag = OptionBag(self,
None,
undefined,
properties=None,
)
option_bag = OptionBag()
option_bag.set_option(self,
None,
undefined)
try:
self.validate(value)
self.validate_with_option(value,
option_bag,
loaded=True,
)
self.sync_validate_with_option(value,
option_bag)
except ValueError as err:
str_err = str(err)
if not str_err:
raise ValueError(_('invalid default_multi value "{0}" '
'for option "{1}"').format(str(value),
self.impl_get_display_name())
) from err
raise ValueError(_(f'invalid default_multi value "{value}" for option '
f'"{self.impl_get_display_name()}", {str_err}')
) from err
self.impl_get_display_name()))
else:
raise ValueError(_('invalid default_multi value "{0}" '
'for option "{1}", {2}').format(str(value),
self.impl_get_display_name(),
str_err))
if _multi is submulti:
if not isinstance(default_multi, Calculation):
if not isinstance(default_multi, list):
@ -143,90 +152,70 @@ class Option(BaseOption):
else:
test_multi_value(default_multi)
_setattr(self, '_default_multi', default_multi)
option_bag = OptionBag(self,
None,
undefined,
properties=None,
)
self.impl_validate(default,
option_bag,
loaded=True,
)
self.impl_validate(default,
option_bag,
check_error=False,
loaded=True,
)
self.value_dependencies(default)
option_bag = OptionBag()
option_bag.set_option(self,
None,
undefined)
self.sync_impl_validate(default,
option_bag)
self.sync_impl_validate(default,
option_bag,
check_error=False)
self.value_dependencies(default, _dependencies_information)
if (is_multi and default != []) or \
(not is_multi and default is not None):
if is_multi and isinstance(default, list):
default = tuple(default)
_setattr(self, '_default', default)
if _dependencies_information[0] or _dependencies_information[1]:
self._dependencies_information = _dependencies_information
def value_dependencies(self,
value: Any,
_dependencies_information: List[str],
) -> Any:
"""parse dependancies to add dependencies
"""
if isinstance(value, list):
for val in value:
if isinstance(value, list):
self.value_dependencies(val)
self.value_dependencies(val, _dependencies_information)
elif isinstance(value, Calculation):
self.value_dependency(val)
self.value_dependency(val, _dependencies_information)
elif isinstance(value, Calculation):
self.value_dependency(value)
self.value_dependency(value, _dependencies_information)
def value_dependency(self,
value: Any,
_dependencies_information: List[str],
) -> Any:
"""parse dependancy to add dependencies
"""
for param in chain(value.params.args, value.params.kwargs.values()):
if isinstance(param, ParamOption):
# pylint: disable=protected-access
param.option._add_dependency(self)
self._has_dependency = True
elif isinstance(param, ParamSelfInformation):
_dependencies_information[1].append(param.information_name)
elif isinstance(param, ParamInformation):
dest = self
if isinstance(param, ParamSelfInformation):
opt = self
elif param.option:
dest = param.option
opt = self
else:
opt = None
if not getattr(dest, '_dependencies_information', {}):
dest._dependencies_information = {}
dest._dependencies_information.setdefault(param.information_name, []).append(opt)
_dependencies_information[0].append(param.information_name)
#__________________________________________________________________________
# option's information
def impl_is_multi(self) -> bool:
"""is it a multi option
"""
return getattr(self, '_multi', 1) != 1
def impl_is_submulti(self) -> bool:
"""is it a submulti option
"""
return getattr(self, '_multi', 1) == 2
def impl_is_dynsymlinkoption(self) -> bool:
"""is a dynsymlinkoption?
"""
return False
def get_type(self) -> str:
"""get the type of option
"""
return self._type
# _display_name for compatibility with older version than 3.0rc3
return getattr(self, '_type', self._display_name)
def get_display_type(self) -> str:
return self._display_name
def impl_getdefault(self) -> Any:
"""accessing the default value
"""
"accessing the default value"
is_multi = self.impl_is_multi()
default = getattr(self, '_default', undefined)
if default is undefined:
@ -234,13 +223,13 @@ class Option(BaseOption):
default = []
else:
default = None
elif is_multi and isinstance(default, tuple):
default = list(default)
else:
if is_multi and isinstance(default, list):
default = list(default)
return default
def impl_getdefault_multi(self) -> Any:
"""accessing the default value for a multi
"""
"accessing the default value for a multi"
if self.impl_is_submulti():
default_value = []
else:
@ -248,35 +237,105 @@ class Option(BaseOption):
return getattr(self, '_default_multi', default_value)
def impl_get_extra(self,
key: str,
) -> Any:
"""if extra parameters are store get it
"""
key: str) -> Any:
extra = getattr(self, '_extra', {})
if isinstance(extra, tuple):
if key in extra[0]:
return extra[1][extra[0].index(key)]
return None
return extra.get(key)
else:
return extra.get(key)
#__________________________________________________________________________
# validator
def impl_validate(self,
value: Any,
option_bag: OptionBag,
check_error: bool=True,
loaded: bool=False,
) -> bool:
def sync_impl_validate(self,
value: Any,
option_bag: OptionBag,
check_error: bool=True) -> None:
"""
"""
is_warnings_only = getattr(self, '_warnings_only', False)
def do_validation(_value,
_index):
if isinstance(_value, list):
raise ValueError(_('which must not be a list').format(_value,
self.impl_get_display_name()))
if _value is not None:
if check_error:
# option validation
self.validate(_value)
self.sync_validate_with_option(_value,
option_bag)
if ((check_error and not is_warnings_only) or
(not check_error and is_warnings_only)):
try:
self.second_level_validation(_value,
is_warnings_only)
except ValueError as err:
if is_warnings_only:
warnings.warn_explicit(ValueWarning(_value,
self._display_name,
self,
'{0}'.format(err),
_index),
ValueWarning,
self.__class__.__name__, 0)
else:
raise err
try:
err_index = None
if isinstance(value, Calculation):
pass
elif not self.impl_is_multi():
val = value
do_validation(val, None)
elif self.impl_is_submulti():
if not isinstance(value, list):
raise ValueError(_('which must be a list'))
for err_index, lval in enumerate(value):
if isinstance(lval, Calculation):
continue
if not isinstance(lval, list):
raise ValueError(_('which "{}" must be a list of list'
'').format(lval))
for val in lval:
if isinstance(val, Calculation):
continue
do_validation(val,
err_index)
else:
# it's a multi
if not isinstance(value, list):
raise ValueError(_('which must be a list'))
for err_index, val in enumerate(value):
if isinstance(val, Calculation):
continue
do_validation(val,
err_index)
except ValueError as err:
raise ValueOptionError(value,
self._display_name,
option_bag.ori_option,
'{0}'.format(err),
err_index)
async def impl_validate(self,
value: Any,
option_bag: OptionBag,
check_error: bool=True) -> None:
"""Return True if value is really valid
If not validate or invalid return it returns False
"""
config_bag = option_bag.config_bag
force_index = option_bag.index
is_warnings_only = getattr(self, '_warnings_only', False)
if check_error and config_bag is not undefined and \
not 'validator' in config_bag.properties:
return False
def _is_not_unique(value, option_bag):
# if set(value) has not same length than value
if config_bag is undefined or not check_error or \
@ -291,12 +350,10 @@ class Option(BaseOption):
raise ValueError(_('the value "{}" is not unique'
'').format(val))
def calculation_validator(val,
_index,
):
async def calculation_validator(val,
_index):
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
if ((check_error and not calc_is_warnings_only) or
(not check_error and calc_is_warnings_only)):
try:
@ -310,38 +367,31 @@ class Option(BaseOption):
soption_bag.index = _index
kwargs['orig_value'] = value
validator.execute(soption_bag,
**kwargs,
)
await validator.execute(soption_bag,
leadership_must_have_index=True,
**kwargs)
except ValueWarning as warn:
warnings.warn_explicit(ValueWarning(val,
self.get_type(),
self._display_name,
self,
str(warn),
_index,
),
'{0}'.format(warn),
_index),
ValueWarning,
self.__class__.__name__, 319)
self.__class__.__name__, 356)
def do_validation(_value,
_index,
):
#
async def do_validation(_value,
_index):
if isinstance(_value, list):
raise ValueError(_('which must not be a list').format(_value,
self.impl_get_display_name()),
)
self.impl_get_display_name()))
if isinstance(_value, Calculation) and config_bag is undefined:
return
return False
if _value is not None:
if check_error:
# option validation
self.validate(_value)
self.validate_with_option(_value,
option_bag,
loaded=loaded,
)
await self.validate_with_option(_value,
option_bag)
if ((check_error and not is_warnings_only) or
(not check_error and is_warnings_only)):
try:
@ -350,40 +400,36 @@ class Option(BaseOption):
except ValueError as err:
if is_warnings_only:
warnings.warn_explicit(ValueWarning(_value,
self.get_type(),
self._display_name,
self,
str(err),
'{0}'.format(err),
_index),
ValueWarning,
self.__class__.__name__, 0)
else:
raise err
if not loaded:
calculation_validator(_value,
_index,
)
val = value
err_index = force_index
await calculation_validator(_value,
_index)
try:
val = value
err_index = force_index
if not self.impl_is_multi():
do_validation(val, None)
await do_validation(val, None)
elif force_index is not None:
if self.impl_is_submulti():
if not isinstance(value, list):
raise ValueError(_('which must be a list'))
for val in value:
do_validation(val,
force_index,
)
_is_not_unique(value,
option_bag,
)
await do_validation(val,
force_index)
_is_not_unique(value, option_bag)
else:
do_validation(val,
force_index,
)
await do_validation(val,
force_index)
elif isinstance(value, Calculation) and config_bag is undefined:
pass
elif not isinstance(value, list):
raise ValueError(_('which must be a list'))
elif self.impl_is_submulti():
for err_index, lval in enumerate(value):
if isinstance(lval, Calculation):
@ -392,89 +438,86 @@ class Option(BaseOption):
raise ValueError(_('which "{}" must be a list of list'
'').format(lval))
for val in lval:
do_validation(val,
await do_validation(val,
err_index)
_is_not_unique(lval, option_bag)
elif not isinstance(value, list):
raise ValueError(_('which must be a list'))
else:
# FIXME suboptimal, not several time for whole=True!
# FIXME subtimal, not several time is whole=True!
for err_index, val in enumerate(value):
do_validation(val,
err_index,
)
await do_validation(val,
err_index)
_is_not_unique(value, option_bag)
except ValueError as err:
if config_bag is undefined or \
'demoting_error_warning' not in config_bag.properties:
raise ValueOptionError(val,
self.get_type(),
self._display_name,
option_bag.ori_option,
str(err),
'{0}'.format(err),
err_index) from err
warnings.warn_explicit(ValueErrorWarning(val,
self.get_type(),
self._display_name,
option_bag.ori_option,
str(err),
'{0}'.format(err),
err_index),
ValueErrorWarning,
self.__class__.__name__, 0)
return False
return True
def validate_with_option(self,
value: Any,
option_bag: OptionBag,
loaded: bool,
) -> None:
"""validation function with option
"""
def _validate_calculator(self,
callback: Callable,
callback_params: Optional[Params]=None) -> None:
if callback is None:
return
default_multi = getattr(self, '_default_multi', None)
is_multi = self.impl_is_multi()
default = self.impl_getdefault()
if (not is_multi and (default is not None or default_multi is not None)) or \
(is_multi and (default != [] or default_multi is not None)):
raise ValueError(_('default value not allowed if option "{0}" '
'is calculated').format(self.impl_getname()))
def sync_validate_with_option(self,
value: Any,
option_bag: OptionBag) -> None:
pass
async def validate_with_option(self,
value: Any,
option_bag: OptionBag) -> None:
pass
def second_level_validation(self,
value: Any,
warnings_only: bool,
) -> None:
"""less import validation function
"""
warnings_only: bool) -> None:
pass
def impl_is_leader(self):
"""check if option is a leader in a leadership
"""
leadership = self.impl_get_leadership()
if leadership is None:
return False
return leadership.is_leader(self)
def impl_is_follower(self):
"""check if option is a leader in a follower
"""
leadership = self.impl_get_leadership()
if leadership is None:
return False
return not leadership.is_leader(self)
def impl_get_leadership(self):
"""get leadership
"""
leadership = getattr(self, '_leadership', None)
if leadership is None:
return leadership
#pylint: disable=not-callable
return leadership()
def to_dynoption(self,
rootpath: str,
suffix: str,
dyn_parent,
ori_dyn,
) -> SynDynOption:
"""tranforme a dynoption to a syndynoption
"""
return SynDynOption(self,
rootpath,
suffix,
dyn_parent,
ori_dyn,
)
def validate(self, value: Any):
"""option needs a validate function
"""
raise NotImplementedError()

356
tiramisu/option/optiondescription.py
View file

@ -18,43 +18,37 @@
# the rough pypy's guys: http://codespeak.net/svn/pypy/dist/pypy/config/
# the whole pypy projet is under MIT licence
# ____________________________________________________________
"""OptionDescription
"""
import weakref
from copy import copy
from typing import Optional, Iterator, Union, List
from ..i18n import _
from ..setting import ConfigBag, OptionBag, groups, undefined, owners, Undefined
from .baseoption import BaseOption
from .syndynoptiondescription import SubDynOptionDescription, SynDynOptionDescription
from .syndynoptiondescription import SynDynOptionDescription, SynDynLeadership
from ..error import ConfigError, ConflictError
class CacheOptionDescription(BaseOption):
"""manage cache for option description
"""
__slots__ = ('_cache_force_store_values',
'_cache_dependencies_information',
)
def impl_already_build_caches(self) -> bool:
"""is a readonly option?
"""
return self.impl_is_readonly()
def _build_cache(self,
_consistencies=None,
_consistencies_id=0,
currpath: List[str]=None,
cache_option=None,
force_store_values=None,
dependencies_information=None,
display_name=None,
) -> None:
async def _build_cache(self,
path='',
_consistencies=None,
_consistencies_id=0,
currpath: List[str]=None,
cache_option=None,
force_store_values=None,
dependencies_information=None,
display_name=None,
) -> None:
"""validate options and set option has readonly option
"""
# pylint: disable=too-many-branches,too-many-arguments
# _consistencies is None only when we start to build cache
if _consistencies is None:
init = True
@ -71,231 +65,202 @@ class CacheOptionDescription(BaseOption):
# cache already set
raise ConfigError(_('option description seems to be part of an other '
'config'))
for option in self.get_children(config_bag=undefined, # pylint: disable=no-member
dyn=False,
):
for option in await self.get_children(config_bag=undefined,
dyn=False):
if __debug__:
cache_option.append(option)
sub_currpath = currpath + [option.impl_getname()]
subpath = '.'.join(sub_currpath)
if isinstance(option, OptionDescription):
# pylint: disable=protected-access
option._build_cache(_consistencies,
_consistencies_id,
sub_currpath,
cache_option,
force_store_values,
dependencies_information,
display_name,
)
await option._build_cache(subpath,
_consistencies,
_consistencies_id,
sub_currpath,
cache_option,
force_store_values,
dependencies_information,
display_name)
else:
for information, options in option.get_dependencies_information().items():
if None in options:
dependencies_information.setdefault(information, []).append(option)
for information in option.get_dependencies_information():
dependencies_information.setdefault(information, []).append(option)
is_multi = option.impl_is_multi()
if not option.impl_is_symlinkoption():
properties = option.impl_getproperties()
if 'force_store_value' in properties:
force_store_values.append(option)
# if __debug__ and ('force_default_on_freeze' in properties or \
# 'force_metaconfig_on_freeze' in properties) and \
# 'frozen' not in properties and \
# option.impl_is_leader():
# raise ConfigError(_('a leader ({0}) cannot have '
# '"force_default_on_freeze" or '
# '"force_metaconfig_on_freeze" '
# 'property without "frozen"'
# '').format(option.impl_get_display_name()))
if __debug__ and ('force_default_on_freeze' in properties or \
'force_metaconfig_on_freeze' in properties) and \
'frozen' not in properties and \
option.impl_is_leader():
raise ConfigError(_('a leader ({0}) cannot have '
'"force_default_on_freeze" or '
'"force_metaconfig_on_freeze" '
'property without "frozen"'
'').format(option.impl_get_display_name()))
if option.impl_is_readonly():
raise ConflictError(_('duplicate option: {0}').format(option))
if not self.impl_is_readonly() and display_name:
option._display_name_function = display_name # pylint: disable=protected-access
option._path = subpath # pylint: disable=protected-access
option._set_readonly() # pylint: disable=protected-access
option._display_name_function = display_name
option._path = subpath
option._set_readonly()
if init:
self._cache_force_store_values = force_store_values # pylint: disable=attribute-defined-outside-init
self._cache_dependencies_information = dependencies_information # pylint: disable=attribute-defined-outside-init
self._path = self._name # pylint: disable=attribute-defined-outside-init,no-member
self._cache_force_store_values = force_store_values
self._cache_dependencies_information = dependencies_information
self._path = self._name
self._set_readonly()
def impl_build_force_store_values(self,
config_bag: ConfigBag,
) -> None:
"""set value to force_store_values option
"""
# pylint: disable=too-many-branches
def do_option_bags(option):
async def impl_build_force_store_values(self,
config_bag: ConfigBag,
) -> None:
async def do_option_bags(option):
if option.issubdyn():
dynopt = option.getsubdyn()
yield from dynopt.get_sub_children(option,
config_bag,
index=None,
)
rootpath = dynopt.impl_getpath()
subpaths = [rootpath] + option.impl_getpath()[len(rootpath) + 1:].split('.')[1:]
for suffix in await dynopt.get_suffixes(config_bag):
path_suffix = dynopt.convert_suffix_to_path(suffix)
subpath = '.'.join([subp + path_suffix for subp in subpaths])
doption = option.to_dynoption(subpath,
suffix,
dynopt,
)
doption_bag = OptionBag()
doption_bag.set_option(doption,
None,
config_bag,
)
yield doption_bag
else:
yield OptionBag(option,
None,
config_bag,
properties=None,
)
option_bag = OptionBag()
option_bag.set_option(option,
None,
config_bag)
yield option_bag
if 'force_store_value' not in config_bag.properties:
return
values = config_bag.context.get_values()
values = config_bag.context.cfgimpl_get_values()
for option in self._cache_force_store_values:
if option.impl_is_follower():
leader = option.impl_get_leadership().get_leader()
for leader_option_bag in do_option_bags(leader):
async for leader_option_bag in do_option_bags(leader):
leader_option_bag.properties = frozenset()
follower_len = len(values.get_value(leader_option_bag)[0])
follower_len = len(await values.getvalue(leader_option_bag))
if option.issubdyn():
subpath = leader_option_bag.option.rootpath
doption = option.to_dynoption(subpath,
leader_option_bag.option.impl_getsuffix(),
leader_option_bag.option.dyn_parent,
leader_option_bag.option.ori_dyn,
)
else:
doption = option
subpath = doption.impl_getpath()
for index in range(follower_len):
option_bag = OptionBag(doption,
index,
config_bag,
properties=frozenset(),
)
if values.hasvalue(subpath, index=index):
if await values._p_.hasvalue(config_bag.connection,
subpath,
index,
):
continue
value = values.get_value(option_bag)[0]
option_bag = OptionBag()
option_bag.set_option(doption,
index,
config_bag,
)
option_bag.properties = frozenset()
value = await values.getvalue(option_bag)
if value is None:
continue
values.set_storage_value(subpath,
index,
value,
owners.forced,
)
await values._p_.setvalue(config_bag.connection,
subpath,
value,
owners.forced,
index,
False)
else:
for option_bag in do_option_bags(option):
async for option_bag in do_option_bags(option):
option_bag.properties = frozenset()
value = values.get_value(option_bag)[0]
value = await values.getvalue(option_bag)
if value is None:
continue
if values.hasvalue(option_bag.path):
if await values._p_.hasvalue(config_bag.connection,
option_bag.option.impl_getpath(),
):
continue
values.set_storage_value(option_bag.path,
None,
value,
owners.forced,
)
await values._p_.setvalue(config_bag.connection,
option_bag.path,
value,
owners.forced,
None,
False,
)
class OptionDescriptionWalk(CacheOptionDescription):
"""get child of option description
"""
__slots__ = ('_children',)
def get_child(self,
name: str,
config_bag: ConfigBag,
subpath: str,
*,
dynoption=None,
option_suffix: Optional[str]=None,
allow_dynoption: bool=False,
) -> Union[BaseOption, SynDynOptionDescription]:
"""get a child
"""
async def get_child(self,
name: str,
config_bag: ConfigBag,
subpath: str,
) -> Union[BaseOption, SynDynOptionDescription]:
# if not dyn
if name in self._children[0]: # pylint: disable=no-member
option = self._children[1][self._children[0].index(name)] # pylint: disable=no-member
if option.impl_is_dynoptiondescription():
if allow_dynoption:
option_suffix = None
else:
raise AttributeError(_(f'unknown option "{name}" '
"in root optiondescription (it's a dynamic option)"
))
if name in self._children[0]:
option = self._children[1][self._children[0].index(name)]
if option.issubdyn():
return option.to_dynoption(subpath,
option_suffix,
option,
)
raise AttributeError(_(f'unknown option "{name}" '
"in root optiondescription (it's a dynamic option)"
))
return option
# if dyn
if dynoption:
self_opt = dynoption
else:
self_opt = self
for child in self._children[1]: # pylint: disable=no-member
if not child.impl_is_dynoptiondescription():
continue
for suffix in child.get_suffixes(config_bag,
dynoption,
):
if name != child.impl_getname(suffix):
continue
return child.to_dynoption(subpath,
suffix,
child,
)
if self.impl_get_group_type() == groups.root: # pylint: disable=no-member
for child in self._children[1]:
if child.impl_is_dynoptiondescription():
cname = child.impl_getname()
if name.startswith(cname):
for suffix in await child.get_suffixes(config_bag):
if name == cname + child.convert_suffix_to_path(suffix):
return child.to_dynoption(subpath,
suffix,
child)
if self.impl_get_group_type() == groups.root:
raise AttributeError(_(f'unknown option "{name}" '
'in root optiondescription'
))
raise AttributeError(_(f'unknown option "{name}" '
f'in optiondescription "{self_opt.impl_get_display_name()}"'
))
def get_children(self,
config_bag: Union[ConfigBag, Undefined],
*,
dyn: bool=True,
#path: Optional[str]=None,
dynoption=None,
option_suffix: Optional[str]=None,
) -> Union[BaseOption, SynDynOptionDescription]:
"""get children
"""
# if path:
# subpath = path
if dynoption:
self_opt = dynoption
else:
self_opt = self
raise AttributeError(_(f'unknown option "{name}" '
f'in optiondescription "{self.impl_get_display_name()}"'
))
async def get_children(self,
config_bag: Union[ConfigBag, Undefined],
dyn: bool=True,
) -> Union[BaseOption, SynDynOptionDescription]:
if not dyn or config_bag is undefined or \
config_bag.context.get_description() == self:
config_bag.context.cfgimpl_get_description() == self:
subpath = ''
else:
subpath = self_opt.impl_getpath()
for child in self._children[1]: # pylint: disable=no-member
subpath = self.impl_getpath()
children = []
for child in self._children[1]:
if dyn and child.impl_is_dynoptiondescription():
for suffix in child.get_suffixes(config_bag,
dynoption,
):
yield child.to_dynoption(subpath,
suffix,
child,
)
elif dyn and child.issubdyn() or child.impl_is_dynsymlinkoption():
yield child.to_dynoption(subpath,
option_suffix,
child,
)
for suffix in await child.get_suffixes(config_bag):
children.append(child.to_dynoption(subpath,
suffix,
child))
else:
yield child
children.append(child)
return children
def get_children_recursively(self,
bytype: Optional[BaseOption],
byname: Optional[str],
config_bag: ConfigBag,
self_opt: BaseOption=None,
) -> Iterator[Union[BaseOption, SynDynOptionDescription]]:
"""get children recursively
"""
async def get_children_recursively(self,
bytype: Optional[BaseOption],
byname: Optional[str],
config_bag: ConfigBag,
self_opt: BaseOption=None) -> Iterator[Union[BaseOption, SynDynOptionDescription]]:
if self_opt is None:
self_opt = self
for option in self_opt.get_children(config_bag):
for option in await self_opt.get_children(config_bag):
if option.impl_is_optiondescription():
for subopt in option.get_children_recursively(bytype,
byname,
config_bag,
):
async for subopt in option.get_children_recursively(bytype,
byname,
config_bag):
yield subopt
elif (byname is None or option.impl_getname() == byname) and \
(bytype is None or isinstance(option, bytype)):
@ -345,39 +310,25 @@ class OptionDescription(OptionDescriptionWalk):
if dynopt_names:
for dynopt in dynopt_names:
if child != dynopt and child.startswith(dynopt):
raise ConflictError(_(f'the option\'s name "{child}" start as '
f'the dynoptiondescription\'s name "{dynopt}"'))
raise ConflictError(_('the option\'s name "{}" start as '
'the dynoptiondescription\'s name "{}"').format(child, dynopt))
old = child
self._children = children_
# the group_type is useful for filtering OptionDescriptions in a config
self._group_type = groups.default
def _setsubdyn(self,
subdyn,
) -> None:
for child in self._children[1]:
child._setsubdyn(subdyn)
super()._setsubdyn(subdyn)
def impl_is_optiondescription(self) -> bool:
"""the option is an option description
"""
return True
def impl_is_dynoptiondescription(self) -> bool:
"""the option is not dynamic
"""
return False
def impl_is_leadership(self) -> bool:
"""the option is not a leadership
"""
return False
# ____________________________________________________________
def impl_set_group_type(self,
group_type: groups.GroupType,
) -> None:
group_type: groups.GroupType) -> None:
"""sets a given group object to an OptionDescription
:param group_type: an instance of `GroupType` or `LeadershipGroupType`
@ -387,7 +338,7 @@ class OptionDescription(OptionDescriptionWalk):
if self._group_type != groups.default:
raise ValueError(_('cannot change group_type if already set '
'(old {0}, new {1})').format(self._group_type,
group_type))
group_type))
if not isinstance(group_type, groups.GroupType):
raise ValueError(_('group_type: {0}'
' not allowed').format(group_type))
@ -396,27 +347,16 @@ class OptionDescription(OptionDescriptionWalk):
self._group_type = group_type
def impl_get_group_type(self) -> groups.GroupType:
"""get the group type of option description
"""
return self._group_type
def to_dynoption(self,
rootpath: str,
suffix: str,
ori_dyn) -> SynDynOptionDescription:
"""get syn dyn option description
"""
if suffix is None:
return SubDynOptionDescription(self,
rootpath,
ori_dyn,
)
return SynDynOptionDescription(self,
rootpath,
suffix,
ori_dyn)
def impl_is_dynsymlinkoption(self) -> bool:
"""option is not a dyn symlink option
"""
return False

Some files were not shown because too many files have changed in this diff Show more