Infra/tiramisu
5
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

remove _cache_paths (path is now directly in option)

Browse Source 
better TiramisuAPI support
This commit is contained in:
Emmanuel Garette
2018-09-08 20:17:20 +02:00
parent e0cab0063e
commit aa9aef6e78
13 changed files with 627 additions and 633 deletions
Download Patch File Download Diff File Expand all files Collapse all files

780
test/auto/test_auto.py
View File

@ -70,6 +70,299 @@ def autocheck(func):
return wrapper
def _autocheck_default_value(cfg, path, conf, **kwargs):
"""set and get values
"""
# check if is a multi, a master or a slave
multi = cfg.unrestraint.option(path).option.ismulti()
submulti_ = cfg.unrestraint.option(path).option.issubmulti()
isslave = cfg.unrestraint.option(path).option.isslave()
# set default value (different if value is multi or not)
empty_value = kwargs['default']
# test default value (should be empty)
# cannot test for slave (we cannot get all values for a slave)
with warnings.catch_warnings(record=True) as w:
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(path).value.get() == empty_value
assert cfg.config(conf).forcepermissive.option(path).value.get() == empty_value
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(path).value.get()")
assert cfg.config(conf).forcepermissive.option(path).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg.config(conf).option(path).value.get()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(path).value.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(path, 0).value.get() == empty_value
assert cfg.config(conf).option(path, 1).value.get() == empty_value
assert cfg.config(conf).forcepermissive.option(path, 0).value.get() == empty_value
assert cfg.config(conf).forcepermissive.option(path, 1).value.get() == empty_value
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(path, 0).value.get()")
assert cfg.config(conf).forcepermissive.option(path, 0).value.get() == empty_value
assert cfg.config(conf).forcepermissive.option(path, 1).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg.config(conf).option(path, 0).value.get()")
raises(PropertiesOptionError, "cfg.config(conf).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).option.ismulti()
submulti_ = cfg.unrestraint.option(pathwrite).option.issubmulti()
ismaster = cfg.unrestraint.option(pathwrite).option.ismaster()
isslave = cfg.unrestraint.option(pathwrite).option.isslave()
if not multi:
first_value = FIRST_VALUE
elif submulti_ is False:
if not isslave:
first_value = LIST_FIRST_VALUE
else:
second_value = LIST_SECOND_VALUE[1]
else:
if not isslave:
first_value = SUBLIST_FIRST_VALUE
else:
second_value = SUBLIST_SECOND_VALUE[1]
# for slave should have an index and good length
# for master must append, not set
with warnings.catch_warnings(record=True) as w:
if ismaster:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
raises(APIError, "cfg.config(conf).option(pathwrite, 0).value.set(first_value[0])")
if not set_permissive:
cfg.config(conf).option(pathwrite).value.set([first_value[0]])
else:
cfg.config(conf).forcepermissive.option(pathwrite).value.set([first_value[0]])
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set([first_value[0]])")
if set_permissive:
cfg.config(conf).forcepermissive.option(pathwrite).value.set([first_value[0]])
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set([first_value[0]])")
raises(PropertiesOptionError,
"cfg.config(conf).forcepermissive.option(pathwrite).value.set([first_value[0]])")
if len(first_value) > 1:
raises(APIError, "cfg.config(conf).unrestraint.option(pathwrite).value.set(first_value[1])")
elif isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not set_permissive:
cfg.config(conf).option(pathwrite, 1).value.set(second_value)
else:
cfg.config(conf).forcepermissive.option(pathwrite, 1).value.set(second_value)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite, 1).value.set(second_value)")
if set_permissive:
cfg.config(conf).forcepermissive.option(pathwrite, 1).value.set(second_value)
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite, 1).value.set(second_value)")
raises(PropertiesOptionError,
"cfg.config(conf).forcepermissive.option(pathwrite, 1).value.set(second_value)")
raises(APIError,
"cfg.config(conf).unrestraint.option(pathwrite).value.set([second_value, second_value])")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not set_permissive:
cfg.config(conf).option(pathwrite).value.set(first_value)
else:
cfg.config(conf).forcepermissive.option(pathwrite).value.set(first_value)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set(first_value)")
if set_permissive:
cfg.config(conf).forcepermissive.option(pathwrite).value.set(first_value)
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set(first_value)")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathwrite).value.set(first_value)")
#FIXME raises(APIError, "cfg.config(conf).unrestraint.option(pathwrite).value.set(first_value)")
def _getproperties(multi, isslave, kwargs):
# define properties
properties = copy(PROPERTIES_LIST)
if multi and not isslave:
default_props = ['empty']
properties.append('empty')
else:
default_props = []
extra_properties = kwargs.get('extra_properties')
if extra_properties:
properties.extend(extra_properties)
default_props.extend(extra_properties)
return default_props, frozenset(properties)
def _check_properties(cfg, mcfg, pathread, conf, kwargs, props_permissive, props):
if not cfg.unrestraint.option(pathread).option.isslave():
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert set(cfg.config(conf).option(pathread).property.get()) == set(props_permissive)
assert set(cfg.config(conf).option(pathread).property.get()) == set(props)
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).property.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).property.get()")
if not kwargs.get('propertyerror', False):
assert set(cfg.config(conf).forcepermissive.option(pathread).property.get()) == set(props_permissive)
assert set(cfg.config(conf).forcepermissive.option(pathread).property.get()) == set(props)
else:
assert PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread).property.get()"
assert PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread).property.get()"
assert set(cfg.config(conf).unrestraint.option(pathread).property.get()) == set(props_permissive)
assert set(cfg.config(conf).unrestraint.option(pathread).property.get()) == set(props)
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert set(cfg.config(conf).option(pathread, 0).property.get()) == set(props_permissive)
assert set(cfg.config(conf).option(pathread, 0).property.get()) == set(props)
#
assert set(cfg.config(conf).option(pathread, 1).property.get()) == set(props_permissive)
assert set(cfg.config(conf).option(pathread, 1).property.get()) == set(props)
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).property.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).property.get()")
#
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 1).property.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 1).property.get()")
if not kwargs.get('propertyerror', False):
assert set(cfg.config(conf).forcepermissive.option(pathread, 0).property.get()) == set(props_permissive)
assert set(cfg.config(conf).forcepermissive.option(pathread, 0).property.get()) == set(props)
#
assert set(cfg.config(conf).forcepermissive.option(pathread, 1).property.get()) == set(props_permissive)
assert set(cfg.config(conf).forcepermissive.option(pathread, 1).property.get()) == set(props)
else:
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread, 0).property.get()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread, 0).property.get()")
#
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread, 1).property.get()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread, 1).property.get()")
assert set(cfg.config(conf).unrestraint.option(pathread, 0).property.get()) == set(props_permissive)
assert set(cfg.config(conf).unrestraint.option(pathread, 0).property.get()) == set(props)
#
assert set(cfg.config(conf).unrestraint.option(pathread, 1).property.get()) == set(props_permissive)
assert set(cfg.config(conf).unrestraint.option(pathread, 1).property.get()) == set(props)
def _property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi or a slave
multi = cfg.unrestraint.option(pathread).option.ismulti()
isslave = cfg.unrestraint.option(pathread).option.isslave()
# define properties
properties = copy(PROPERTIES_LIST)
if multi and not isslave:
default_props = ['empty']
properties.append('empty')
else:
default_props = []
extra_properties = kwargs.get('extra_properties')
if extra_properties:
properties.extend(extra_properties)
default_props.extend(extra_properties)
default_props, properties = _getproperties(multi, isslave, kwargs)
if confwrite == confread:
_check_properties(cfg, mcfg, pathread, confwrite, kwargs, default_props, default_props)
else:
_check_properties(cfg, mcfg, pathread, confread, kwargs, default_props, default_props)
# set properties with permissive
for prop in properties:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg.config(confread).option(pathwrite).property.add(prop)
elif not kwargs.get('propertyerror', False):
cfg.config(confread).forcepermissive.option(pathwrite).property.add(prop)
else:
cfg.config(confread).unrestraint.option(pathwrite).property.add(prop)
if confwrite == confread:
_check_properties(cfg, mcfg, pathread, confwrite, kwargs, properties, properties)
else:
_check_properties(cfg, mcfg, pathread, confread, kwargs, properties, properties)
def _autocheck_get_value(cfg, pathread, conf, **kwargs):
set_permissive = kwargs.get('set_permissive', True)
multi = cfg.unrestraint.option(pathread).option.ismulti()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
isslave = cfg.unrestraint.option(pathread).option.isslave()
empty_value = kwargs['default']
if not multi:
first_value = FIRST_VALUE
elif submulti_ is False:
if not isslave:
first_value = LIST_FIRST_VALUE
else:
second_value = LIST_SECOND_VALUE[1]
else:
if not isslave:
first_value = SUBLIST_FIRST_VALUE
else:
second_value = SUBLIST_SECOND_VALUE[1]
# get value after set value without permissive
with warnings.catch_warnings(record=True) as w:
if isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread, 0).value.get() == empty_value
assert cfg.config(conf).option(pathread, 1).value.get() == second_value
assert cfg.config(conf).forcepermissive.option(pathread, 0).value.get() == empty_value
assert cfg.config(conf).forcepermissive.option(pathread, 1).value.get() == second_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).value.get()")
assert cfg.config(conf).forcepermissive.option(pathread, 0).value.get() == empty_value
if set_permissive:
assert cfg.config(conf).forcepermissive.option(pathread, 1).value.get() == second_value
else:
assert cfg.config(conf).forcepermissive.option(pathread, 1).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).value.get()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread, 0).value.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread).value.get() == first_value
assert cfg.config(conf).forcepermissive.option(pathread).value.get() == first_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
if set_permissive:
assert cfg.config(conf).forcepermissive.option(pathread).value.get() == first_value
else:
assert cfg.config(conf).forcepermissive.option(pathread).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread).value.get()")
def _check_owner(cfg, pathread, conf, kwargs, owner, permissive_owner):
isslave = cfg.unrestraint.option(pathread).option.isslave()
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread).owner.get() == owner
assert cfg.config(conf).forcepermissive.option(pathread).owner.get() == owner
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.get()")
assert cfg.config(conf).forcepermissive.option(pathread).owner.get() == permissive_owner
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.get()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread).owner.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread, 0).owner.get() == 'default'
assert cfg.config(conf).forcepermissive.option(pathread, 0).owner.get() == 'default'
assert cfg.config(conf).option(pathread, 1).owner.get() == owner
assert cfg.config(conf).forcepermissive.option(pathread, 1).owner.get() == owner
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 1).owner.get()")
assert cfg.config(conf).forcepermissive.option(pathread, 0).owner.get() == 'default'
assert cfg.config(conf).forcepermissive.option(pathread, 1).owner.get() == permissive_owner
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread, 0).owner.get()")
@autocheck
def autocheck_option_multi(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
@ -110,90 +403,51 @@ def autocheck_default_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite,
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread).owner.get() == 'default'
assert cfg.forcepermissive.config(conf).option(pathread).owner.get() == 'default'
assert cfg.config(conf).forcepermissive.option(pathread).owner.get() == 'default'
#
assert cfg.config(conf).option(pathread).owner.isdefault()
assert cfg.forcepermissive.config(conf).option(pathread).owner.isdefault()
assert cfg.config(conf).forcepermissive.option(pathread).owner.isdefault()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.get()")
assert cfg.forcepermissive.config(conf).option(pathread).owner.get() == 'default'
assert cfg.config(conf).forcepermissive.option(pathread).owner.get() == 'default'
#
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.isdefault()")
assert cfg.forcepermissive.config(conf).option(pathread).owner.isdefault()
assert cfg.config(conf).forcepermissive.option(pathread).owner.isdefault()
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).owner.get()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread).owner.get()")
#
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.isdefault()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).owner.isdefault()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread).owner.isdefault()")
#
assert cfg.unrestraint.config(conf).option(pathread).owner.get() == 'default'
assert cfg.unrestraint.config(conf).option(pathread).owner.isdefault()
assert cfg.config(conf).unrestraint.option(pathread).owner.get() == 'default'
assert cfg.config(conf).unrestraint.option(pathread).owner.isdefault()
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread, 0).owner.get() == 'default'
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.get() == 'default'
assert cfg.config(conf).forcepermissive.option(pathread, 0).owner.get() == 'default'
#
assert cfg.config(conf).option(pathread, 0).owner.isdefault()
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.isdefault()
assert cfg.config(conf).forcepermissive.option(pathread, 0).owner.isdefault()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.get()")
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.get() == 'default'
assert cfg.config(conf).forcepermissive.option(pathread, 0).owner.get() == 'default'
#
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.isdefault()")
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.isdefault()
assert cfg.config(conf).forcepermissive.option(pathread, 0).owner.isdefault()
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread, 0).owner.get()")
#
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.isdefault()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread, 0).owner.isdefault()")
assert cfg.unrestraint.config(conf).option(pathread, 0).owner.get() == 'default'
assert cfg.unrestraint.config(conf).option(pathread, 0).owner.isdefault()
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread, 0).owner.isdefault()")
assert cfg.config(conf).unrestraint.option(pathread, 0).owner.get() == 'default'
assert cfg.config(conf).unrestraint.option(pathread, 0).owner.isdefault()
do(confread)
if confread != confwrite:
do(confwrite)
def _autocheck_default_value(cfg, path, conf, **kwargs):
"""set and get values
"""
# check if is a multi, a master or a slave
multi = cfg.unrestraint.option(path).option.ismulti()
submulti_ = cfg.unrestraint.option(path).option.issubmulti()
isslave = cfg.unrestraint.option(path).option.isslave()
# set default value (different if value is multi or not)
empty_value = kwargs['default']
# test default value (should be empty)
# cannot test for slave (we cannot get all values for a slave)
with warnings.catch_warnings(record=True) as w:
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(path).value.get() == empty_value
assert cfg.forcepermissive.config(conf).option(path).value.get() == empty_value
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(path).value.get()")
assert cfg.forcepermissive.config(conf).option(path).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg.config(conf).option(path).value.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(path).value.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(path, 0).value.get() == empty_value
assert cfg.config(conf).option(path, 1).value.get() == empty_value
assert cfg.forcepermissive.config(conf).option(path, 0).value.get() == empty_value
assert cfg.forcepermissive.config(conf).option(path, 1).value.get() == empty_value
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(path, 0).value.get()")
assert cfg.forcepermissive.config(conf).option(path, 0).value.get() == empty_value
assert cfg.forcepermissive.config(conf).option(path, 1).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg.config(conf).option(path, 0).value.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(path, 0).value.get()")
@autocheck
def autocheck_default_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
_autocheck_default_value(cfg, pathread, confread, **kwargs)
@ -202,79 +456,6 @@ def autocheck_default_value(cfg, mcfg, pathread, pathwrite, confread, confwrite,
def _set_value(cfg, pathwrite, conf, **kwargs):
set_permissive = kwargs.get('set_permissive', True)
multi = cfg.unrestraint.option(pathwrite).option.ismulti()
submulti_ = cfg.unrestraint.option(pathwrite).option.issubmulti()
ismaster = cfg.unrestraint.option(pathwrite).option.ismaster()
isslave = cfg.unrestraint.option(pathwrite).option.isslave()
if not multi:
first_value = FIRST_VALUE
elif submulti_ is False:
if not isslave:
first_value = LIST_FIRST_VALUE
else:
second_value = LIST_SECOND_VALUE[1]
else:
if not isslave:
first_value = SUBLIST_FIRST_VALUE
else:
second_value = SUBLIST_SECOND_VALUE[1]
# for slave should have an index and good length
# for master must append, not set
with warnings.catch_warnings(record=True) as w:
if ismaster:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
raises(APIError, "cfg.config(conf).option(pathwrite, 0).value.set(first_value[0])")
if not set_permissive:
cfg.config(conf).option(pathwrite).value.set([first_value[0]])
else:
cfg.forcepermissive.config(conf).option(pathwrite).value.set([first_value[0]])
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set([first_value[0]])")
if set_permissive:
cfg.forcepermissive.config(conf).option(pathwrite).value.set([first_value[0]])
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set([first_value[0]])")
raises(PropertiesOptionError,
"cfg.forcepermissive.config(conf).option(pathwrite).value.set([first_value[0]])")
if len(first_value) > 1:
raises(APIError, "cfg.unrestraint.config(conf).option(pathwrite).value.set(first_value[1])")
elif isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not set_permissive:
cfg.config(conf).option(pathwrite, 1).value.set(second_value)
else:
cfg.forcepermissive.config(conf).option(pathwrite, 1).value.set(second_value)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite, 1).value.set(second_value)")
if set_permissive:
cfg.forcepermissive.config(conf).option(pathwrite, 1).value.set(second_value)
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite, 1).value.set(second_value)")
raises(PropertiesOptionError,
"cfg.forcepermissive.config(conf).option(pathwrite, 1).value.set(second_value)")
raises(APIError,
"cfg.unrestraint.config(conf).option(pathwrite).value.set([second_value, second_value])")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not set_permissive:
cfg.config(conf).option(pathwrite).value.set(first_value)
else:
cfg.forcepermissive.config(conf).option(pathwrite).value.set(first_value)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set(first_value)")
if set_permissive:
cfg.forcepermissive.config(conf).option(pathwrite).value.set(first_value)
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set(first_value)")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathwrite).value.set(first_value)")
#FIXME raises(APIError, "cfg.unrestraint.config(conf).option(pathwrite).value.set(first_value)")
@autocheck
def autocheck_set_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
_set_value(cfg, pathwrite, confwrite, **kwargs)
@ -299,96 +480,43 @@ def autocheck_get_value_permissive(cfg, mcfg, pathread, pathwrite, confread, con
if isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread, 0).value.get() == empty_value
assert cfg.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
assert cfg.config(conf).forcepermissive.option(pathread, 0).value.get() == empty_value
if submulti_:
assert cfg.config(conf).option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1]
assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1]
assert cfg.config(conf).forcepermissive.option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1]
else:
assert cfg.config(conf).option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
assert cfg.config(conf).forcepermissive.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "assert cfg.config(conf).option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert cfg.config(conf).option(pathread, 1).value.get()")
assert cfg.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
assert cfg.config(conf).forcepermissive.option(pathread, 0).value.get() == empty_value
if submulti_:
assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1]
assert cfg.config(conf).forcepermissive.option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1]
else:
assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
assert cfg.config(conf).forcepermissive.option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
else:
raises(PropertiesOptionError, "assert cfg.config(conf).option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert cfg.config(conf).option(pathread, 1).value.get()")
raises(PropertiesOptionError, "assert cfg.forcepermissive.config(conf).option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get()")
raises(PropertiesOptionError, "assert cfg.config(conf).forcepermissive.option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert cfg.config(conf).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.config(conf).option(pathread).value.get() == first_value
assert cfg.forcepermissive.config(conf).option(pathread).value.get() == first_value
assert cfg.config(conf).forcepermissive.option(pathread).value.get() == first_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
assert cfg.forcepermissive.config(conf).option(pathread).value.get() == first_value
assert cfg.config(conf).forcepermissive.option(pathread).value.get() == first_value
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread).value.get()")
with warnings.catch_warnings(record=True) as w:
do(confread)
if confread != confwrite:
do(confwrite)
def _autocheck_get_value(cfg, pathread, conf, **kwargs):
set_permissive = kwargs.get('set_permissive', True)
multi = cfg.unrestraint.option(pathread).option.ismulti()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
isslave = cfg.unrestraint.option(pathread).option.isslave()
empty_value = kwargs['default']
if not multi:
first_value = FIRST_VALUE
elif submulti_ is False:
if not isslave:
first_value = LIST_FIRST_VALUE
else:
second_value = LIST_SECOND_VALUE[1]
else:
if not isslave:
first_value = SUBLIST_FIRST_VALUE
else:
second_value = SUBLIST_SECOND_VALUE[1]
# get value after set value without permissive
with warnings.catch_warnings(record=True) as w:
if isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread, 0).value.get() == empty_value
assert cfg.config(conf).option(pathread, 1).value.get() == second_value
assert cfg.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get() == second_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).value.get()")
assert cfg.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
if set_permissive:
assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get() == second_value
else:
assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).value.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread, 0).value.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread).value.get() == first_value
assert cfg.forcepermissive.config(conf).option(pathread).value.get() == first_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
if set_permissive:
assert cfg.forcepermissive.config(conf).option(pathread).value.get() == first_value
else:
assert cfg.forcepermissive.config(conf).option(pathread).value.get() == empty_value
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).value.get()")
@autocheck
def autocheck_get_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
_set_value(cfg, pathwrite, confwrite, set_permissive=False, **kwargs)
@ -407,7 +535,7 @@ def autocheck_value_slave(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
isslave = cfg.unrestraint.option(pathread).option.isslave()
if not isslave:
if kwargs.get('propertyerror', False):
raises(APIError, "cfg.unrestraint.config(confread).option(pathread).value.len()")
raises(APIError, "cfg.config(confread).unrestraint.option(pathread).value.len()")
return
if kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.option(pathread).value.len()")
@ -421,10 +549,10 @@ def autocheck_value_slave(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
def do(conf):
if not kwargs.get('permissive', False):
length = cfg.config(conf).option(pathread).value.len()
assert cfg.forcepermissive.config(conf).option(pathread).value.len() == length
assert cfg.config(conf).forcepermissive.option(pathread).value.len() == length
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.len()")
length = cfg.forcepermissive.config(conf).option(pathread).value.len()
length = cfg.config(conf).forcepermissive.option(pathread).value.len()
assert length == 2
do(confread)
if confread != confwrite:
@ -494,14 +622,14 @@ def autocheck_reset_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, *
assert cfg.config(conf).option(pathread, 1).value.get() == second_value[1]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).value.get()")
assert cfg.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get() == second_value[1]
assert cfg.config(conf).forcepermissive.option(pathread, 0).value.get() == empty_value
assert cfg.config(conf).forcepermissive.option(pathread, 1).value.get() == second_value[1]
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread).value.get() == empty_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
assert cfg.forcepermissive.config(conf).option(pathread).value.get() == first_value
assert cfg.config(conf).forcepermissive.option(pathread).value.get() == first_value
with warnings.catch_warnings(record=True) as w:
do(confread)
if confread != confwrite:
@ -517,13 +645,13 @@ def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite,
with warnings.catch_warnings(record=True) as w:
if not kwargs.get('propertyerror', False):
master_value = cfg.forcepermissive.config(confread).option(pathread).value.get()
master_value = cfg.config(confread).forcepermissive.option(pathread).value.get()
len_value = len(master_value)
master_value.append(undefined)
assert len(cfg.forcepermissive.config(confread).option(pathread).value.get()) == len_value
assert len(cfg.config(confread).forcepermissive.option(pathread).value.get()) == len_value
with warnings.catch_warnings(record=True) as w:
cfg.forcepermissive.config(confwrite).option(pathread).value.set(master_value)
new_master_value = cfg.forcepermissive.config(confread).option(pathread).value.get()
new_master_value = cfg.config(confread).forcepermissive.option(pathread).value.get()
len_new = len(new_master_value)
assert len_value + 1 == len_new
assert new_master_value[-1] == kwargs['default_multi']
@ -533,16 +661,16 @@ def autocheck_append_value(cfg, mcfg, pathread, pathwrite, confread, confwrite,
else:
slave_path += '.third'
for idx in range(len_new):
assert cfg.forcepermissive.config(confread).option(slave_path, idx).value.get() == kwargs['default_multi']
assert cfg.config(confread).forcepermissive.option(slave_path, idx).value.get() == kwargs['default_multi']
#
if not submulti_:
value = 'value'
else:
value = ['value']
master_value.append(value)
assert len(cfg.forcepermissive.config(confread).option(pathread).value.get()) == len(new_master_value)
assert len(cfg.config(confread).forcepermissive.option(pathread).value.get()) == len(new_master_value)
cfg.forcepermissive.config(confwrite).option(pathread).value.set(master_value)
assert cfg.forcepermissive.config(confread).option(pathread).value.get()[-1] == value
assert cfg.config(confread).forcepermissive.option(pathread).value.get()[-1] == value
@autocheck
@ -568,32 +696,32 @@ def autocheck_pop_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **k
with warnings.catch_warnings(record=True) as w:
cfg.forcepermissive.config(confwrite).option(pathread).value.set(values)
cfg.forcepermissive.config(confwrite).option(a_slave, 1).value.set(slave_value)
cfg.forcepermissive.config(confread).option(a_slave, 0).value.get() == kwargs['default_multi']
assert cfg.forcepermissive.config(confread).option(a_slave, 0).owner.isdefault() is True
cfg.forcepermissive.config(confread).option(a_slave, 1).value.get() == slave_value
assert cfg.forcepermissive.config(confread).option(a_slave, 1).owner.isdefault() is False
cfg.forcepermissive.config(confread).option(a_slave, 2).value.get() == kwargs['default_multi']
assert cfg.forcepermissive.config(confread).option(a_slave, 2).owner.isdefault() is True
cfg.forcepermissive.config(confread).option(a_slave, 3).value.get() == kwargs['default_multi']
assert cfg.forcepermissive.config(confread).option(a_slave, 3).owner.isdefault() is True
cfg.config(confread).forcepermissive.option(a_slave, 0).value.get() == kwargs['default_multi']
assert cfg.config(confread).forcepermissive.option(a_slave, 0).owner.isdefault() is True
cfg.config(confread).forcepermissive.option(a_slave, 1).value.get() == slave_value
assert cfg.config(confread).forcepermissive.option(a_slave, 1).owner.isdefault() is False
cfg.config(confread).forcepermissive.option(a_slave, 2).value.get() == kwargs['default_multi']
assert cfg.config(confread).forcepermissive.option(a_slave, 2).owner.isdefault() is True
cfg.config(confread).forcepermissive.option(a_slave, 3).value.get() == kwargs['default_multi']
assert cfg.config(confread).forcepermissive.option(a_slave, 3).owner.isdefault() is True
#
cfg.forcepermissive.config(confwrite).option(pathread).value.pop(3)
cfg.forcepermissive.config(confread).option(a_slave, 0).value.get() == kwargs['default_multi']
assert cfg.forcepermissive.config(confread).option(a_slave, 0).owner.isdefault() is True
cfg.forcepermissive.config(confread).option(a_slave, 1).value.get() == slave_value
assert cfg.forcepermissive.config(confread).option(a_slave, 1).owner.isdefault() is False
cfg.forcepermissive.config(confread).option(a_slave, 2).value.get() == kwargs['default_multi']
assert cfg.forcepermissive.config(confread).option(a_slave, 2).owner.isdefault() is True
cfg.config(confread).forcepermissive.option(a_slave, 0).value.get() == kwargs['default_multi']
assert cfg.config(confread).forcepermissive.option(a_slave, 0).owner.isdefault() is True
cfg.config(confread).forcepermissive.option(a_slave, 1).value.get() == slave_value
assert cfg.config(confread).forcepermissive.option(a_slave, 1).owner.isdefault() is False
cfg.config(confread).forcepermissive.option(a_slave, 2).value.get() == kwargs['default_multi']
assert cfg.config(confread).forcepermissive.option(a_slave, 2).owner.isdefault() is True
#
cfg.forcepermissive.config(confwrite).option(pathread).value.pop(0)
cfg.forcepermissive.config(confread).option(a_slave, 0).value.get() == slave_value
assert cfg.forcepermissive.config(confread).option(a_slave, 0).owner.isdefault() is False
cfg.forcepermissive.config(confread).option(a_slave, 1).value.get() == kwargs['default_multi']
assert cfg.forcepermissive.config(confread).option(a_slave, 1).owner.isdefault() is True
cfg.config(confread).forcepermissive.option(a_slave, 0).value.get() == slave_value
assert cfg.config(confread).forcepermissive.option(a_slave, 0).owner.isdefault() is False
cfg.config(confread).forcepermissive.option(a_slave, 1).value.get() == kwargs['default_multi']
assert cfg.config(confread).forcepermissive.option(a_slave, 1).owner.isdefault() is True
#
cfg.forcepermissive.config(confwrite).option(pathread).value.pop(0)
cfg.forcepermissive.config(confread).option(a_slave, 0).value.get() == kwargs['default_multi']
assert cfg.forcepermissive.config(confread).option(a_slave, 0).owner.isdefault() is True
cfg.config(confread).forcepermissive.option(a_slave, 0).value.get() == kwargs['default_multi']
assert cfg.config(confread).forcepermissive.option(a_slave, 0).owner.isdefault() is True
@autocheck
@ -640,69 +768,6 @@ def autocheck_display(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwa
assert(cfg.config(confwrite).config.dict()) == make_dict_value
def _getproperties(multi, isslave, kwargs):
# define properties
properties = copy(PROPERTIES_LIST)
if multi and not isslave:
default_props = ['empty']
properties.append('empty')
else:
default_props = []
extra_properties = kwargs.get('extra_properties')
if extra_properties:
properties.extend(extra_properties)
default_props.extend(extra_properties)
return default_props, frozenset(properties)
def _check_properties(cfg, mcfg, pathread, conf, kwargs, props_permissive, props):
if not cfg.unrestraint.option(pathread).option.isslave():
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert set(cfg.config(conf).option(pathread).property.get()) == set(props_permissive)
assert set(cfg.config(conf).option(pathread).property.get()) == set(props)
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).property.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).property.get()")
if not kwargs.get('propertyerror', False):
assert set(cfg.forcepermissive.config(conf).option(pathread).property.get()) == set(props_permissive)
assert set(cfg.forcepermissive.config(conf).option(pathread).property.get()) == set(props)
else:
assert PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).property.get()"
assert PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).property.get()"
assert set(cfg.unrestraint.config(conf).option(pathread).property.get()) == set(props_permissive)
assert set(cfg.unrestraint.config(conf).option(pathread).property.get()) == set(props)
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert set(cfg.config(conf).option(pathread, 0).property.get()) == set(props_permissive)
assert set(cfg.config(conf).option(pathread, 0).property.get()) == set(props)
#
assert set(cfg.config(conf).option(pathread, 1).property.get()) == set(props_permissive)
assert set(cfg.config(conf).option(pathread, 1).property.get()) == set(props)
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).property.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).property.get()")
#
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 1).property.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 1).property.get()")
if not kwargs.get('propertyerror', False):
assert set(cfg.forcepermissive.config(conf).option(pathread, 0).property.get()) == set(props_permissive)
assert set(cfg.forcepermissive.config(conf).option(pathread, 0).property.get()) == set(props)
#
assert set(cfg.forcepermissive.config(conf).option(pathread, 1).property.get()) == set(props_permissive)
assert set(cfg.forcepermissive.config(conf).option(pathread, 1).property.get()) == set(props)
else:
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread, 0).property.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread, 0).property.get()")
#
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread, 1).property.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread, 1).property.get()")
assert set(cfg.unrestraint.config(conf).option(pathread, 0).property.get()) == set(props_permissive)
assert set(cfg.unrestraint.config(conf).option(pathread, 0).property.get()) == set(props)
#
assert set(cfg.unrestraint.config(conf).option(pathread, 1).property.get()) == set(props_permissive)
assert set(cfg.unrestraint.config(conf).option(pathread, 1).property.get()) == set(props)
@autocheck
def autocheck_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""get property from path
@ -713,52 +778,19 @@ def autocheck_property(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kw
default_props, properties = _getproperties(multi, isslave, kwargs)
_check_properties(cfg, mcfg, pathread, confread, kwargs, default_props, default_props)
if confread != confwrite:
if confread == confwrite:
_check_properties(cfg, mcfg, pathread, confread, kwargs, default_props, default_props)
else:
_check_properties(cfg, mcfg, pathread, confwrite, kwargs, default_props, default_props)
# set properties without permissive
for prop in properties:
cfg.unrestraint.config(confread).option(pathwrite).property.add(prop)
_check_properties(cfg, mcfg, pathread, confread, kwargs, properties, properties)
#if confread != confwrite:
# _check_properties(cfg, mcfg, pathread, confwrite, kwargs, properties, properties)
def _property_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi or a slave
multi = cfg.unrestraint.option(pathread).option.ismulti()
isslave = cfg.unrestraint.option(pathread).option.isslave()
# define properties
properties = copy(PROPERTIES_LIST)
if multi and not isslave:
default_props = ['empty']
properties.append('empty')
cfg.unrestraint.config(confwrite).option(pathwrite).property.add(prop)
if confread == confwrite:
_check_properties(cfg, mcfg, pathread, confread, kwargs, properties, properties)
else:
default_props = []
extra_properties = kwargs.get('extra_properties')
if extra_properties:
properties.extend(extra_properties)
default_props.extend(extra_properties)
default_props, properties = _getproperties(multi, isslave, kwargs)
_check_properties(cfg, mcfg, pathread, confwrite, kwargs, properties, properties)
_check_properties(cfg, mcfg, pathread, confwrite, kwargs, default_props, default_props)
#if confwrite != confread:
# _check_properties(cfg, mcfg, pathread, confread, kwargs, default_props, default_props)
# set properties with permissive
for prop in properties:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
cfg.config(confread).option(pathwrite).property.add(prop)
if not kwargs.get('propertyerror', False):
cfg.forcepermissive.config(confread).option(pathwrite).property.add(prop)
cfg.unrestraint.config(confread).option(pathwrite).property.add(prop)
_check_properties(cfg, mcfg, pathread, confwrite, kwargs, properties, properties)
#if confwrite != confread:
# _check_properties(cfg, mcfg, pathread, confread, kwargs, properties, properties)
@autocheck
@ -780,8 +812,9 @@ def autocheck_reset_property(cfg, mcfg, pathread, pathwrite, confread, confwrite
# reset properties without permissive
cfg.unrestraint.config(confwrite).option(pathwrite).property.reset()
_check_properties(cfg, mcfg, pathread, confread, kwargs, default_props, default_props)
if confread != confwrite:
if confread == confwrite:
_check_properties(cfg, mcfg, pathread, confread, kwargs, default_props, default_props)
else:
_check_properties(cfg, mcfg, pathread, confwrite, kwargs, default_props, default_props)
@ -799,8 +832,6 @@ def autocheck_reset_property_permissive(cfg, mcfg, pathread, pathwrite, confread
cfg.unrestraint.option(pathwrite).property.reset()
_check_properties(cfg, mcfg, pathread, confwrite, kwargs, default_props, default_props)
if confread != confwrite:
_check_properties(cfg, mcfg, pathread, confread, kwargs, default_props, default_props)
@autocheck
@ -809,34 +840,6 @@ def autocheck_context_owner(cfg, mcfg, pathread, pathwrite, confread, confwrite,
assert owner == kwargs['owner']
def _check_owner(cfg, pathread, conf, kwargs, owner, permissive_owner):
isslave = cfg.unrestraint.option(pathread).option.isslave()
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread).owner.get() == owner
assert cfg.forcepermissive.config(conf).option(pathread).owner.get() == owner
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.get()")
assert cfg.forcepermissive.config(conf).option(pathread).owner.get() == permissive_owner
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).owner.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert cfg.config(conf).option(pathread, 0).owner.get() == 'default'
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.get() == 'default'
assert cfg.config(conf).option(pathread, 1).owner.get() == owner
assert cfg.forcepermissive.config(conf).option(pathread, 1).owner.get() == owner
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 1).owner.get()")
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.get() == 'default'
assert cfg.forcepermissive.config(conf).option(pathread, 1).owner.get() == permissive_owner
else:
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread, 0).owner.get()")
@autocheck
def autocheck_owner_with_value(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""value is now changed, check owner in this case
@ -884,12 +887,12 @@ def autocheck_default_owner_with_value_permissive(cfg, mcfg, pathread, pathwrite
# test if is default owner with permissive
if not kwargs.get('propertyerror', False):
if not isslave:
assert cfg.forcepermissive.config(conf).option(pathread).owner.isdefault() is False
assert cfg.config(conf).forcepermissive.option(pathread).owner.isdefault() is False
else:
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.isdefault() is True
assert cfg.forcepermissive.config(conf).option(pathread, 1).owner.isdefault() is False
assert cfg.config(conf).forcepermissive.option(pathread, 0).owner.isdefault() is True
assert cfg.config(conf).forcepermissive.option(pathread, 1).owner.isdefault() is False
#FIXME else:
# raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(conf).forcepermissive.option(pathread).owner.isdefault()")
do(confwrite)
if confwrite != confread:
do(confread)
@ -1015,30 +1018,28 @@ def autocheck_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **
call_path = pathread + 'call'
cfg.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset(['disabled']))
# have permissive
# have permissive?
assert cfg.unrestraint.config(confwrite).option(pathread).permissive.get() == frozenset(['disabled'])
#if confwrite != confread:
# assert cfg.unrestraint.config(confread).option(pathread).permissive.get() == frozenset(['disabled'])
# assert cfg.config(confread).unrestraint.option(pathread).permissive.get() == frozenset(['disabled'])
# can access to disabled value
ckwargs = copy(kwargs)
ckwargs['propertyerror'] = False
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
_autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
cfg.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset(['disabled', 'hidden']))
cfg.config(confread).unrestraint.option(pathwrite).permissive.set(frozenset(['disabled', 'hidden']))
if kwargs['callback']:
cfg.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset(['disabled', 'hidden']))
cfg.config(confread).unrestraint.option(call_path).permissive.set(frozenset(['disabled', 'hidden']))
# can access to all value except when optiondescript have hidden
if not ckwargs.get('permissive_od', False):
ckwargs['permissive'] = False
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
if ckwargs.get('permissive_od', False):
# set permissive to OptionDescription
cfg.unrestraint.config(confwrite).option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset(['disabled',
cfg.config(confread).unrestraint.option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset(['disabled',
'hidden']))
ckwargs['permissive'] = False
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
@ -1046,32 +1047,24 @@ def autocheck_permissive(cfg, mcfg, pathread, pathwrite, confread, confwrite, **
# _autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
# only hidden
cfg.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset(['hidden']))
cfg.config(confread).unrestraint.option(pathwrite).permissive.set(frozenset(['hidden']))
if callback:
cfg.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset(['hidden']))
cfg.config(confread).unrestraint.option(call_path).permissive.set(frozenset(['hidden']))
if ckwargs.get('permissive_od', False):
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
cfg.unrestraint.config(confwrite).option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset(['hidden']))
cfg.config(confread).unrestraint.option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset(['hidden']))
ckwargs = copy(kwargs)
ckwargs['permissive'] = False
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
#if confread != confwrite:
# _autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
# no permissive
cfg.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset())
cfg.config(confread).unrestraint.option(pathwrite).permissive.set(frozenset())
if callback:
cfg.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset())
cfg.config(confread).unrestraint.option(call_path).permissive.set(frozenset())
if ckwargs.get('permissive_od', False):
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
cfg.unrestraint.config(confwrite).option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset())
cfg.config(confread).unrestraint.option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset())
_autocheck_default_value(cfg, pathread, confread, **kwargs)
#if confread != confwrite:
# _autocheck_default_value(cfg, pathread, confwrite, **kwargs)
@autocheck
@ -1106,15 +1099,15 @@ def autocheck_find(cfg, mcfg, pathread, pathwrite, confread, confwrite, **kwargs
def do(conf):
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert option == _getoption(cfg.config(conf).option.find(name, first=True))
assert option == _getoption(cfg.forcepermissive.config(conf).option.find(name, first=True))
assert option == _getoption(cfg.config(conf).forcepermissive.option.find(name, first=True))
elif kwargs.get('permissive', False):
raises(AttributeError, "cfg.config(conf).option.find(name, first=True)")
assert option == _getoption(cfg.forcepermissive.config(conf).option.find(name, first=True))
assert option == _getoption(cfg.config(conf).forcepermissive.option.find(name, first=True))
else:
raises(AttributeError, "cfg.config(conf).option.find(name, first=True)")
raises(AttributeError, "cfg.forcepermissive.config(conf).option.find(name, first=True)")
assert option == _getoption(cfg.unrestraint.config(conf).option.find(name, first=True))
assert [option] == _getoptions(cfg.unrestraint.config(conf).option.find(name))
raises(AttributeError, "cfg.config(conf).forcepermissive.option.find(name, first=True)")
assert option == _getoption(cfg.config(conf).unrestraint.option.find(name, first=True))
assert [option] == _getoptions(cfg.config(conf).unrestraint.option.find(name))
do(confread)
if confread != confwrite:
do(confwrite)
@ -1648,7 +1641,7 @@ DICT_PATHS = [
OrderedDict([('first', {}),
('second', {'second': {'disabled': True}}),
('third', {'third': {'hidden': True}})
]),
]),
#test a config with two optiondescription
OrderedDict([('subod.subsubod.first', {}),
('subod.subsubod.second', {'second': {'disabled': True}}),
@ -1748,7 +1741,8 @@ def test_options(paths):
continue
for default in (False, True):
for multi in (False, True, submulti):
# for meta in (False,):
pass
# for meta in (True,):
# for callback in (False,):
# for consistency in (False,):
# for require in (False,):
@ -1757,7 +1751,7 @@ def test_options(paths):
# if callback and default_multi:
# continue
# for default in (False,):
# for multi in (True,):
# for multi in (False,):
# print(meta, callback, consistency, require, default_multi, symlink, default, multi)
if multi is submulti and default:
continue

154
test/test_cache.py
View File

@ -47,8 +47,8 @@ def test_cache_config():
def test_cache():
od1 = make_description()
cfg = Config(od1)
values = cfg._config.cfgimpl_get_values()
settings = cfg._config.cfgimpl_get_settings()
values = cfg._config_bag.context.cfgimpl_get_values()
settings = cfg._config_bag.context.cfgimpl_get_settings()
cfg.option('u1').value.get()
assert 'u1' in values._p_.get_cached()
assert 'u1' in settings._p_.get_cached()
@ -98,8 +98,8 @@ def test_cache_importation_permissive():
def test_cache_reset():
od1 = make_description()
cfg = Config(od1)
values = cfg._config.cfgimpl_get_values()
settings = cfg._config.cfgimpl_get_settings()
values = cfg._config_bag.context.cfgimpl_get_values()
settings = cfg._config_bag.context.cfgimpl_get_settings()
#when change a value
cfg.option('u1').value.get()
cfg.option('u2').value.get()
@ -158,8 +158,8 @@ def test_cache_reset():
def test_cache_reset_multi():
od1 = make_description()
cfg = Config(od1)
values = cfg._config.cfgimpl_get_values()
settings = cfg._config.cfgimpl_get_settings()
values = cfg._config_bag.context.cfgimpl_get_values()
settings = cfg._config_bag.context.cfgimpl_get_settings()
cfg.option('u1').value.get()
cfg.option('u3').value.get()
assert 'u1' in values._p_.get_cached()
@ -210,12 +210,12 @@ def test_cache_reset_multi():
def test_reset_cache():
od1 = make_description()
cfg = Config(od1)
values = cfg._config.cfgimpl_get_values()
settings = cfg._config.cfgimpl_get_settings()
values = cfg._config_bag.context.cfgimpl_get_values()
settings = cfg._config_bag.context.cfgimpl_get_settings()
cfg.option('u1').value.get()
assert 'u1' in values._p_.get_cached()
assert 'u1' in settings._p_.get_cached()
cfg._config.cfgimpl_reset_cache(None, None)
cfg._config_bag.context.cfgimpl_reset_cache(None, None)
assert 'u1' not in values._p_.get_cached()
assert 'u1' not in settings._p_.get_cached()
cfg.option('u1').value.get()
@ -227,7 +227,7 @@ def test_reset_cache():
assert 'u1' in settings._p_.get_cached()
assert 'u2' in values._p_.get_cached()
assert 'u2' in settings._p_.get_cached()
cfg._config.cfgimpl_reset_cache(None, None)
cfg._config_bag.context.cfgimpl_reset_cache(None, None)
assert 'u1' not in values._p_.get_cached()
assert 'u1' not in settings._p_.get_cached()
assert 'u2' not in values._p_.get_cached()
@ -237,8 +237,8 @@ def test_reset_cache():
def test_cache_not_cache():
od1 = make_description()
cfg = Config(od1)
values = cfg._config.cfgimpl_get_values()
settings = cfg._config.cfgimpl_get_settings()
values = cfg._config_bag.context.cfgimpl_get_values()
settings = cfg._config_bag.context.cfgimpl_get_settings()
cfg.property.pop('cache')
cfg.option('u1').value.get()
assert 'u1' not in values._p_.get_cached()
@ -253,13 +253,13 @@ def test_cache_master_slave():
maconfig = OptionDescription('toto', '', [interface1])
cfg = Config(maconfig)
cfg.property.read_write()
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {}
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {}
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {}
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {}
#
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
cache = cfg._config.cfgimpl_get_values()._p_.get_cached()
cache = cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached()
if TIRAMISU_VERSION == 2:
assert set(cache.keys()) == set(['ip_admin_eth0.ip_admin_eth0'])
else:
@ -269,7 +269,7 @@ def test_cache_master_slave():
#assert set(cache['ip_admin_eth0.netmask_admin_eth0'].keys()) == set([None])
#assert cache['ip_admin_eth0.netmask_admin_eth0'][None][0] == [None]
#assert cache['ip_admin_eth0.netmask_admin_eth0'][0][0] is None
cache = cfg._config.cfgimpl_get_settings()._p_.get_cached()
cache = cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached()
assert set(cache.keys()) == set([None, 'ip_admin_eth0', 'ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
assert set(cache['ip_admin_eth0'].keys()) == set([None])
assert set(cache['ip_admin_eth0.ip_admin_eth0'].keys()) == set([None])
@ -282,7 +282,7 @@ def test_cache_master_slave():
cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()
cache = cfg._config.cfgimpl_get_values()._p_.get_cached()
cache = cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached()
if TIRAMISU_VERSION == 2:
assert set(cache.keys()) == set(['ip_admin_eth0.ip_admin_eth0'])
else:
@ -293,7 +293,7 @@ def test_cache_master_slave():
#assert cache['ip_admin_eth0.netmask_admin_eth0'][None][0] == [None, None]
#assert cache['ip_admin_eth0.netmask_admin_eth0'][0][0] is None
#assert cache['ip_admin_eth0.netmask_admin_eth0'][1][0] is None
cache = cfg._config.cfgimpl_get_settings()._p_.get_cached()
cache = cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached()
assert set(cache.keys()) == set([None, 'ip_admin_eth0', 'ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
assert set(cache['ip_admin_eth0'].keys()) == set([None])
assert set(cache['ip_admin_eth0.ip_admin_eth0'].keys()) == set([None])
@ -329,79 +329,79 @@ def test_cache_callback():
if TIRAMISU_VERSION == 2:
cfg.property.pop('expire')
cfg.config.dict()
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
# 'val1': {None: (set([]), None)}}
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('val', None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('val', None)},
'val2': {None: ('val', None)},
'val3': {None: ('yes', None)},
'val4': {None: ('val', None)},
'val5': {None: (['yes'], None)}})
cfg.option('val1').value.set('new')
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
# 'val1': {None: (set([]), None)}}
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val3': {None: ('yes', None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val3': {None: ('yes', None)},
'val5': {None: (['yes'], None)}})
cfg.config.dict()
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
# 'val1': {None: (set([]), None)}}
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('yes', None)},
'val4': {None: ('new', None)},
'val5': {None: (['yes'], None)}})
cfg.option('val3').value.set('new2')
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
# 'val1': {None: (set([]), None)},
# 'val3': {None: (set([]), None)}}
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val4': {None: ('new', None)},
'val5': {None: (['yes'], None)}})
cfg.config.dict()
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
# 'val1': {None: (set([]), None)},
# 'val3': {None: (set([]), None)}}
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('new2', None)},
'val4': {None: ('new', None)},
'val5': {None: (['yes'], None)}})
cfg.option('val4').value.set('new3')
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
# 'val1': {None: (set([]), None)},
# 'val3': {None: (set([]), None)},
# 'val4': {None: (set([]), None)}}
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('new2', None)},
'val5': {None: (['yes'], None)}})
cfg.config.dict()
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
# 'val1': {None: (set([]), None)},
# 'val3': {None: (set([]), None)},
# 'val4': {None: (set([]), None)}}
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('new2', None)},
'val4': {None: ('new3', None)},
'val5': {None: (['yes'], None)}})
cfg.option('val5').value.set([undefined, 'new4'])
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
# 'val1': {None: (set([]), None)},
# 'val3': {None: (set([]), None)},
# 'val4': {None: (set([]), None)},
# 'val5': {None: (set(['empty']), None)}}
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('new2', None)},
'val4': {None: ('new3', None)}})
cfg.config.dict()
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
# 'val1': {None: (set([]), None)},
# 'val3': {None: (set([]), None)},
# 'val4': {None: (set([]), None)},
# 'val5': {None: (set(['empty']), None)}}
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1': {None: ('new', None)},
'val2': {None: ('new', None)},
'val3': {None: ('new2', None)},
'val4': {None: ('new3', None)},
@ -435,19 +435,19 @@ def test_cache_master_and_slaves_master():
#None because no value
idx_val2 = None
if TIRAMISU_VERSION == 2:
assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {}
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {}
assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {}
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {}
else:
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (global_props, None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (global_props, None)},
'val1': {None: (val1_props, None)},
'val1.val1': {None: (val1_val1_props, None)},
'val1.val2': {idx_val2: (val1_val2_props, None)}})
# len is 0 so don't get any value
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1.val1': {None: ([], None)}})
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1.val1': {None: ([], None)}})
#
cfg.option('val1.val1').value.set([undefined])
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)}})
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {}
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)}})
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {}
cfg.config.dict()
if TIRAMISU_VERSION == 2:
val_val2 = [None]
@ -457,30 +457,30 @@ def test_cache_master_and_slaves_master():
idx_val2 = 0
val_val2 = None
val_val2_props = {idx_val2: (val1_val2_props, None), None: (set(), None)}
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (global_props, None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (global_props, None)},
'val1': {None: (val1_props, None)},
'val1.val1': {None: (val1_val1_props, None)},
'val1.val2': val_val2_props})
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1.val1': {None: ([None], None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1.val1': {None: ([None], None)},
'val1.val2': {idx_val2: (val_val2, None)}})
cfg.option('val1.val1').value.set([undefined, undefined])
cfg.config.dict()
cfg.option('val1.val2', 1).value.set('oui')
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)}})
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {}
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)}})
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {}
if TIRAMISU_VERSION == 2:
val1_val2_props = {None: (set([]), None), 0: (set([]), None), 1: (set([]), None)}
else:
val1_val2_props = {0: (frozenset([]), None), 1: (frozenset([]), None)}
#assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (global_props, None)},
#assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (global_props, None)},
# 'val1': {None: (val1_props, None)},
# 'val1.val1': {None: (val1_val1_props, None)},
# 'val1.val2': val1_val2_props}
#if TIRAMISU_VERSION == 2:
# assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {'val1.val1': {None: ([None, None], None)},
# assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {'val1.val1': {None: ([None, None], None)},
# 'val1.val2': {None: ([None, 'oui'], None)}}
#else:
# assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {'val1.val1': {None: ([None, None], None)},
# assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {'val1.val1': {None: ([None, None], None)},
# 'val1.val2': {0: (None, None), 1: ('oui', None)}}
@ -509,22 +509,22 @@ def test_cache_master_callback():
val1_val1_props = frozenset(val1_val1_props)
val1_val2_props = frozenset(val1_val2_props)
if TIRAMISU_VERSION == 2:
assert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {}
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {}
assert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {}
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {}
else:
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (global_props, None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (global_props, None)},
'val1': {None: (val1_props, None)},
'val1.val1': {None: (val1_val1_props, None)},
'val1.val2': {None: (val1_val2_props, None)}})
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'val1.val1': {None: ([], None)}})
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'val1.val1': {None: ([], None)}})
cfg.option('val1.val1').value.set([undefined])
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)}})
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)}})
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {}
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {}
cfg.config.dict()
#FIXMEassert cfg._config.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
#FIXMEassert cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached() == {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
# 'val1': {None: (set([]), None)}}
#FIXMEassert cfg._config.cfgimpl_get_values()._p_.get_cached() == {'val1.val1': {None: ([None], None)},
#FIXMEassert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {'val1.val1': {None: ([None], None)},
# 'val1.val2': {None: ([None], None)}
# }
@ -538,46 +538,46 @@ def test_cache_requires():
cfg.property.read_write()
if TIRAMISU_VERSION == 2:
cfg.property.pop('expire')
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {}
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {}
assert cfg.option('ip_address_service').value.get() == None
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
if TIRAMISU_VERSION == 2:
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {'ip_address_service': {None: (None, None)}}
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {'ip_address_service': {None: (None, None)}}
else:
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'ip_address_service': {None: (None, None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'ip_address_service': {None: (None, None)},
'activate_service': {None: (True, None)}})
cfg.config.dict()
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'ip_address_service': {None: (None, None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'ip_address_service': {None: (None, None)},
'activate_service': {None: (True, None)}})
cfg.option('ip_address_service').value.set('1.1.1.1')
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)}})
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'activate_service': {None: (True, None)}})
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'activate_service': {None: (True, None)}})
cfg.config.dict()
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'ip_address_service': {None: ('1.1.1.1', None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'ip_address_service': {None: ('1.1.1.1', None)},
'activate_service': {None: (True, None)}})
cfg.option('activate_service').value.set(False)
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)}})
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)}})
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {}
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {}
cfg.config.dict()
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set(['disabled']), None)}})
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'activate_service': {None: (False, None)}})
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'activate_service': {None: (False, None)}})
def test_cache_global_properties():
@ -587,25 +587,25 @@ def test_cache_global_properties():
od = OptionDescription('service', '', [a, b])
cfg = Config(od)
cfg.property.read_write()
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {}
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {}
assert cfg.option('ip_address_service').value.get() == None
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'disabled', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
if TIRAMISU_VERSION == 2:
assert cfg._config.cfgimpl_get_values()._p_.get_cached() == {'ip_address_service': {None: (None, None)}}
assert cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached() == {'ip_address_service': {None: (None, None)}}
else:
compare(cfg._config.cfgimpl_get_values()._p_.get_cached(), {'ip_address_service': {None: (None, None)},
compare(cfg._config_bag.context.cfgimpl_get_values()._p_.get_cached(), {'ip_address_service': {None: (None, None)},
'activate_service': {None: (True, None)}})
cfg.property.pop('disabled')
assert cfg.option('ip_address_service').value.get() == None
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'frozen', 'hidden', 'validator', 'warnings']), None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'frozen', 'hidden', 'validator', 'warnings']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})
cfg.property.add('test')
assert cfg.option('ip_address_service').value.get() == None
compare(cfg._config.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'frozen', 'hidden', 'validator', 'warnings', 'test']), None)},
compare(cfg._config_bag.context.cfgimpl_get_settings()._p_.get_cached(), {None: {None: (set(['cache', 'frozen', 'hidden', 'validator', 'warnings', 'test']), None)},
'activate_service': {None: (set([]), None)},
'ip_address_service': {None: (set([]), None)}})

11
test/test_config.py
View File

@ -145,17 +145,6 @@ def test_information_config():
raises(ValueError, "config.information.reset('noinfo')")
def test_config_impl_get_path_by_opt():
descr = make_description()
config = Config(descr)
dummy = config.option('gc.dummy').option.get()
boo = config.option('bool').option.get()
unknown = IntOption('test', '')
unknown
assert config._config.cfgimpl_get_description().impl_get_path_by_opt(boo) == 'bool'
assert config._config.cfgimpl_get_description().impl_get_path_by_opt(dummy) == 'gc.dummy'
def to_tuple(val):
ret = []
for v in val:

6
test/test_dereference.py
View File

@ -19,7 +19,7 @@ def test_deref_storage():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
c = Config(o)
w = weakref.ref(c._config.cfgimpl_get_values()._p_)
w = weakref.ref(c._config_bag.context.cfgimpl_get_values()._p_)
del(c)
assert w() is None
@ -28,7 +28,7 @@ def test_deref_value():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
c = Config(o)
w = weakref.ref(c._config.cfgimpl_get_values())
w = weakref.ref(c._config_bag.context.cfgimpl_get_values())
del(c)
assert w() is None
@ -37,7 +37,7 @@ def test_deref_setting():
b = BoolOption('b', '')
o = OptionDescription('od', '', [b])
c = Config(o)
w = weakref.ref(c._config.cfgimpl_get_settings())
w = weakref.ref(c._config_bag.context.cfgimpl_get_settings())
del(c)
assert w() is None

34
test/test_metaconfig.py
View File

@ -199,26 +199,26 @@ def test_meta_meta_set():
errors2 = meta.value.set('od1.i6', 7, only_config=True)
assert len(errors1) == 0
assert len(errors2) == 2
conf1 = meta.config('meta.conf1')._config
conf2 = meta.config('meta.conf2')._config
conf1 = meta.config('meta.conf1')._config_bag.context
conf2 = meta.config('meta.conf2')._config_bag.context
assert meta.config('meta.conf1').option('od1.i1').value.get() == meta.config('meta.conf2').option('od1.i1').value.get() == 7
#
dconfigs = []
for conf in meta.config.find('i1', value=7, first=True).config.list():
dconfigs.append(conf._config)
dconfigs.append(conf._config_bag.context)
assert [conf1, conf2] == dconfigs
meta.config('meta.conf1').option('od1.i1').value.set(8)
#
dconfigs = []
for conf in meta.config.find('i1', first=True).config.list():
dconfigs.append(conf._config)
dconfigs.append(conf._config_bag.context)
assert [conf1, conf2] == dconfigs
assert conf2 == list(meta.config.find('i1', value=7, first=True).config.list())[0]._config
assert conf1 == list(meta.config.find('i1', value=8, first=True).config.list())[0]._config
assert conf2 == list(meta.config.find('i1', value=7, first=True).config.list())[0]._config_bag.context
assert conf1 == list(meta.config.find('i1', value=8, first=True).config.list())[0]._config_bag.context
#
dconfigs = []
for conf in meta.config.find('i5', value=2, first=True).config.list():
dconfigs.append(conf._config)
dconfigs.append(conf._config_bag.context)
assert [conf1, conf2] == dconfigs
#
raises(AttributeError, "meta.config.find('i1', value=10, first=True)")
@ -258,8 +258,8 @@ def test_group_find_firsts():
conf2 = Config(od2, session_id='conf2')
grp = GroupConfig([conf1, conf2])
itr = grp.config.find('i1', first=True).config.list()
conf1._config == next(itr)._config
conf2._config == next(itr)._config
conf1._config_bag.context == next(itr)._config_bag.context
conf2._config_bag.context == next(itr)._config_bag.context
def test_group_group():
@ -307,20 +307,20 @@ def test_meta_master_slaves():
meta = MetaConfig([conf1, conf2])
meta.property.read_only()
itr = meta.config.find('ip_admin_eth0', first=True).config.list()
assert conf1._config == next(itr)._config
assert conf2._config == next(itr)._config
assert conf1._config_bag.context == next(itr)._config_bag.context
assert conf2._config_bag.context == next(itr)._config_bag.context
itr = meta.config.find('netmask_admin_eth0', first=True).config.list()
assert conf1._config == next(itr)._config
assert conf2._config == next(itr)._config
assert conf1._config_bag.context == next(itr)._config_bag.context
assert conf2._config_bag.context == next(itr)._config_bag.context
meta.property.read_write()
raises(AttributeError, "meta.config.find('netmask_admin_eth0', first=True)")
itr = meta.unrestraint.config.find('netmask_admin_eth0', first=True).config.list()
assert conf1._config == next(itr)._config
assert conf2._config == next(itr)._config
assert conf1._config_bag.context == next(itr)._config_bag.context
assert conf2._config_bag.context == next(itr)._config_bag.context
meta.property.read_only()
itr = meta.config.find('netmask_admin_eth0', first=True).config.list()
assert conf1._config == next(itr)._config
assert conf2._config == next(itr)._config
assert conf1._config_bag.context == next(itr)._config_bag.context
assert conf2._config_bag.context == next(itr)._config_bag.context
def test_meta_master_slaves_value2():

1
test/test_permissive.py
View File

@ -79,6 +79,7 @@ def test_permissive_frozen():
api.property.read_write()
api.unrestraint.permissive.set(frozenset(['frozen', 'disabled']))
assert api.unrestraint.permissive.get() == frozenset(['frozen', 'disabled'])
assert api.permissive.get() == frozenset(['frozen', 'disabled'])
try:
api.option('u1').value.set(1)
except PropertiesOptionError as err:

12
test/test_slots.py
View File

@ -150,14 +150,14 @@ def test_slots_config():
od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1])
c = Config(od2)
raises(AttributeError, "c._config.x = 1")
raises(AttributeError, "c._config.cfgimpl_x = 1")
raises(AttributeError, "c._config_bag.context.x = 1")
raises(AttributeError, "c._config_bag.context.cfgimpl_x = 1")
option_bag = OptionBag()
option_bag.set_option(od2,
'a',
None,
ConfigBag(c._config))
sc = c._config.get_subconfig('a', option_bag)
ConfigBag(c._config_bag.context))
sc = c._config_bag.context.get_subconfig('a', option_bag)
assert isinstance(sc, SubConfig)
raises(AttributeError, "sc.x = 1")
raises(AttributeError, "sc.cfgimpl_x = 1")
@ -167,7 +167,7 @@ def test_slots_setting():
od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1])
c = Config(od2)
s = c._config.cfgimpl_get_settings()
s = c._config_bag.context.cfgimpl_get_settings()
s
raises(AttributeError, "s.x = 1")
@ -176,6 +176,6 @@ def test_slots_value():
od1 = OptionDescription('a', '', [])
od2 = OptionDescription('a', '', [od1])
c = Config(od2)
v = c._config.cfgimpl_get_values()
v = c._config_bag.context.cfgimpl_get_values()
v
raises(AttributeError, "v.x = 1")

2
test/test_state.py
View File

@ -223,7 +223,7 @@ def test_diff_information_config():
b.impl_set_information('info2', 'oh')
o = OptionDescription('o', '', [b])
o1 = OptionDescription('o1', '', [o])
c = Config(o1)._config
c = Config(o1)._config_bag.context
raises(NotImplementedError, "dumps(c)")