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

refactor

Browse Source
This commit is contained in:
Emmanuel Garette
2017-11-23 16:56:14 +01:00
parent 119ca85041
commit 527ae40950
13 changed files with 1178 additions and 793 deletions
Download Patch File Download Diff File Expand all files Collapse all files

822
test/api/test_owner.py
View File

@ -8,7 +8,7 @@ from .autopath import do_autopath
do_autopath()
from tiramisu import Config, MetaConfig, \
StrOption, OptionDescription, MasterSlaves, DynOptionDescription, \
getapi, submulti, undefined
getapi, submulti, undefined, owners
from tiramisu.error import PropertiesOptionError, APIError, ConfigError
from collections import OrderedDict
ICON = u'\u2937'
@ -66,7 +66,7 @@ def autocheck(func):
@autocheck
def autocheck_option_multi(api, path, **kwargs):
def autocheck_option_multi(api, path, confread, confwrite, **kwargs):
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.option(path).option.ismulti()
api.option(path).option.issubmulti()
@ -115,53 +115,57 @@ def autocheck_option_multi(api, path, **kwargs):
@autocheck
def autocheck_default_owner(api, path, **kwargs):
def autocheck_default_owner(api, path, confread, confwrite, **kwargs):
"""check different value of owner when any value is set to this option
"""
isslave = api.unrestraint.option(path).option.isslave()
# check if owner is a string "default" and 'isdefault'
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path).owner.get() == 'default'
assert api.forcepermissive.option(path).owner.get() == 'default'
#
assert api.option(path).owner.isdefault()
assert api.forcepermissive.option(path).owner.isdefault()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path).owner.get()")
assert api.forcepermissive.option(path).owner.get() == 'default'
#
raises(PropertiesOptionError, "api.option(path).owner.isdefault()")
assert api.forcepermissive.option(path).owner.isdefault()
def do(conf):
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(path).owner.get() == 'default'
assert api.forcepermissive.config(conf).option(path).owner.get() == 'default'
#
assert api.config(conf).option(path).owner.isdefault()
assert api.forcepermissive.config(conf).option(path).owner.isdefault()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.config(conf).option(path).owner.get()")
assert api.forcepermissive.config(conf).option(path).owner.get() == 'default'
#
raises(PropertiesOptionError, "api.config(conf).option(path).owner.isdefault()")
assert api.forcepermissive.config(conf).option(path).owner.isdefault()
else:
raises(PropertiesOptionError, "api.config(conf).option(path).owner.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path).owner.get()")
#
raises(PropertiesOptionError, "api.config(conf).option(path).owner.isdefault()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path).owner.isdefault()")
else:
raises(PropertiesOptionError, "api.option(path).owner.get()")
raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.get()")
#
raises(PropertiesOptionError, "api.option(path).owner.isdefault()")
raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.isdefault()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path, 0).owner.get() == 'default'
assert api.forcepermissive.option(path, 0).owner.get() == 'default'
#
assert api.option(path, 0).owner.isdefault()
assert api.forcepermissive.option(path, 0).owner.isdefault()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path, 0).owner.get()")
assert api.forcepermissive.option(path, 0).owner.get() == 'default'
#
assert api.option(path, 0).owner.isdefault()
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.isdefault()")
else:
raises(PropertiesOptionError, "api.option(path, 0).owner.get()")
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.get()")
#
raises(PropertiesOptionError, "api.option(path, 0).owner.isdefault()")
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.isdefault()")
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(path, 0).owner.get() == 'default'
assert api.forcepermissive.config(conf).option(path, 0).owner.get() == 'default'
#
assert api.config(conf).option(path, 0).owner.isdefault()
assert api.forcepermissive.config(conf).option(path, 0).owner.isdefault()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.config(conf).option(path, 0).owner.get()")
assert api.forcepermissive.config(conf).option(path, 0).owner.get() == 'default'
#
assert api.config(conf).option(path, 0).owner.isdefault()
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path, 0).owner.isdefault()")
else:
raises(PropertiesOptionError, "api.config(conf).option(path, 0).owner.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path, 0).owner.get()")
#
raises(PropertiesOptionError, "api.config(conf).option(path, 0).owner.isdefault()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path, 0).owner.isdefault()")
# unrestraint is not allowed
raises(APIError, "api.unrestraint.option(path).owner.get()")
raises(APIError, "api.unrestraint.option(path).owner.isdefault()")
# unrestraint is not allowed
raises(APIError, "api.unrestraint.config(conf).option(path).owner.get()")
raises(APIError, "api.unrestraint.config(conf).option(path).owner.isdefault()")
do(confread)
if confread != confwrite:
do(confwrite)
def _getdefault(api, path, multi, isslave, submulti_):
@ -171,7 +175,7 @@ def _getdefault(api, path, multi, isslave, submulti_):
return empty_value
def _autocheck_default_value(api, path, **kwargs):
def _autocheck_default_value(api, path, conf, **kwargs):
"""set and get values
"""
# check if is a multi, a master or a slave
@ -186,35 +190,38 @@ def _autocheck_default_value(api, path, **kwargs):
# cannot test for slave (we cannot get all values for a slave)
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path).value.get() == empty_value
assert api.forcepermissive.option(path).value.get() == empty_value
assert api.config(conf).option(path).value.get() == empty_value
assert api.forcepermissive.config(conf).option(path).value.get() == empty_value
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path).value.get()")
assert api.forcepermissive.option(path).value.get() == empty_value
raises(PropertiesOptionError, "api.config(conf).option(path).value.get()")
assert api.forcepermissive.config(conf).option(path).value.get() == empty_value
else:
raises(PropertiesOptionError, "api.option(path).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()")
raises(PropertiesOptionError, "api.config(conf).option(path).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path).value.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path, 0).value.get() == empty_value
assert api.option(path, 1).value.get() == empty_value
assert api.forcepermissive.option(path, 0).value.get() == empty_value
assert api.forcepermissive.option(path, 1).value.get() == empty_value
assert api.config(conf).option(path, 0).value.get() == empty_value
assert api.config(conf).option(path, 1).value.get() == empty_value
assert api.forcepermissive.config(conf).option(path, 0).value.get() == empty_value
assert api.forcepermissive.config(conf).option(path, 1).value.get() == empty_value
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
assert api.forcepermissive.option(path, 0).value.get() == empty_value
assert api.forcepermissive.option(path, 1).value.get() == empty_value
raises(PropertiesOptionError, "api.config(conf).option(path, 0).value.get()")
assert api.forcepermissive.config(conf).option(path, 0).value.get() == empty_value
assert api.forcepermissive.config(conf).option(path, 1).value.get() == empty_value
else:
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()")
raises(PropertiesOptionError, "api.config(conf).option(path, 0).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path, 0).value.get()")
@autocheck
def autocheck_default_value(api, path, **kwargs):
_autocheck_default_value(api, path, **kwargs)
def autocheck_default_value(api, path, confread, confwrite, **kwargs):
_autocheck_default_value(api, path, confread, **kwargs)
if confread != confwrite:
_autocheck_default_value(api, path, confwrite, **kwargs)
def _autocheck_set_value(api, path, **kwargs):
def _autocheck_set_value(api, path, conf, **kwargs):
set_permissive = kwargs.get('set_permissive', True)
multi = api.unrestraint.option(path).option.ismulti()
submulti_ = api.unrestraint.option(path).option.issubmulti()
@ -231,64 +238,64 @@ def _autocheck_set_value(api, path, **kwargs):
# for master must append, not set
if ismaster:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
raises(APIError, "api.option(path, 0).value.set(first_value[0])")
raises(APIError, "api.config(conf).option(path, 0).value.set(first_value[0])")
if not set_permissive:
api.option(path).value.set([first_value[0]])
api.config(conf).option(path).value.set([first_value[0]])
else:
api.forcepermissive.option(path).value.set([first_value[0]])
api.forcepermissive.config(conf).option(path).value.set([first_value[0]])
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path).value.set([first_value[0]])")
raises(PropertiesOptionError, "api.config(conf).option(path).value.set([first_value[0]])")
if set_permissive:
api.forcepermissive.option(path).value.set([first_value[0]])
api.forcepermissive.config(conf).option(path).value.set([first_value[0]])
else:
raises(PropertiesOptionError, "api.option(path).value.set([first_value[0]])")
raises(PropertiesOptionError, "api.config(conf).option(path).value.set([first_value[0]])")
raises(PropertiesOptionError,
"api.forcepermissive.option(path).value.set([first_value[0]])")
raises(APIError, "api.unrestraint.option(path).value.set(first_value[1])")
"api.forcepermissive.config(conf).option(path).value.set([first_value[0]])")
raises(APIError, "api.unrestraint.config(conf).option(path).value.set(first_value[1])")
elif isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not set_permissive:
api.option(path, 0).value.set(first_value[0])
api.config(conf).option(path, 0).value.set(first_value[0])
else:
api.forcepermissive.option(path, 0).value.set(first_value[0])
api.forcepermissive.config(conf).option(path, 0).value.set(first_value[0])
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path, 0).value.set(first_value[0])")
raises(PropertiesOptionError, "api.config(conf).option(path, 0).value.set(first_value[0])")
if set_permissive:
api.forcepermissive.option(path, 0).value.set(first_value[0])
api.forcepermissive.config(conf).option(path, 0).value.set(first_value[0])
else:
raises(PropertiesOptionError, "api.option(path, 0).value.set(first_value[0])")
raises(PropertiesOptionError, "api.config(conf).option(path, 0).value.set(first_value[0])")
raises(PropertiesOptionError,
"api.forcepermissive.option(path, 0).value.set(first_value[0])")
"api.forcepermissive.config(conf).option(path, 0).value.set(first_value[0])")
raises(APIError,
"api.unrestraint.option(path).value.set([first_value[0], first_value[1]])")
"api.unrestraint.config(conf).option(path).value.set([first_value[0], first_value[1]])")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not set_permissive:
api.option(path).value.set(first_value)
api.config(conf).option(path).value.set(first_value)
else:
api.forcepermissive.option(path).value.set(first_value)
api.forcepermissive.config(conf).option(path).value.set(first_value)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path).value.set(first_value)")
raises(PropertiesOptionError, "api.config(conf).option(path).value.set(first_value)")
if set_permissive:
api.forcepermissive.option(path).value.set(first_value)
api.forcepermissive.config(conf).option(path).value.set(first_value)
else:
raises(PropertiesOptionError, "api.option(path).value.set(first_value)")
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.set(first_value)")
raises(APIError, "api.unrestraint.option(path).value.set(first_value)")
raises(PropertiesOptionError, "api.config(conf).option(path).value.set(first_value)")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path).value.set(first_value)")
raises(APIError, "api.unrestraint.config(conf).option(path).value.set(first_value)")
@autocheck
def autocheck_set_value(api, path, **kwargs):
_autocheck_set_value(api, path, **kwargs)
def autocheck_set_value(api, path, confread, confwrite, **kwargs):
_autocheck_set_value(api, path, confwrite, **kwargs)
@autocheck
def autocheck_get_value_permissive(api, path, **kwargs):
def autocheck_get_value_permissive(api, path, confread, confwrite, **kwargs):
multi = api.unrestraint.option(path).option.ismulti()
submulti_ = api.unrestraint.option(path).option.issubmulti()
isslave = api.unrestraint.option(path).option.isslave()
_autocheck_set_value(api, path, **kwargs)
_autocheck_set_value(api, path, confwrite, **kwargs)
if not multi:
first_value = FIRST_VALUE
elif submulti_ is False:
@ -296,30 +303,34 @@ def autocheck_get_value_permissive(api, path, **kwargs):
else:
first_value = SUBLIST_FIRST_VALUE
# get value after set value without permissive
if isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path, 0).value.get() == first_value[0]
assert api.forcepermissive.option(path, 0).value.get() == first_value[0]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
assert api.forcepermissive.option(path, 0).value.get() == first_value
def do(conf):
# get value after set value without permissive
if isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(path, 0).value.get() == first_value[0]
assert api.forcepermissive.config(conf).option(path, 0).value.get() == first_value[0]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.config(conf).option(path, 0).value.get()")
assert api.forcepermissive.config(conf).option(path, 0).value.get() == first_value
else:
raises(PropertiesOptionError, "api.config(conf).option(path, 0).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path, 0).value.get()")
else:
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path).value.get() == first_value
assert api.forcepermissive.option(path).value.get() == first_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.option(path).value.get()")
assert api.forcepermissive.option(path).value.get() == first_value
else:
raises(PropertiesOptionError, "api.option(path).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()")
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(path).value.get() == first_value
assert api.forcepermissive.config(conf).option(path).value.get() == first_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.config(conf).option(path).value.get()")
assert api.forcepermissive.config(conf).option(path).value.get() == first_value
else:
raises(PropertiesOptionError, "api.config(conf).option(path).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path).value.get()")
do(confread)
if confread != confwrite:
do(confwrite)
def _autocheck_get_value(api, path, **kwargs):
def _autocheck_get_value(api, path, conf, **kwargs):
multi = api.unrestraint.option(path).option.ismulti()
submulti_ = api.unrestraint.option(path).option.issubmulti()
isslave = api.unrestraint.option(path).option.isslave()
@ -334,37 +345,39 @@ def _autocheck_get_value(api, path, **kwargs):
# get value after set value without permissive
if isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path, 0).value.get() == first_value[0]
assert api.forcepermissive.option(path, 0).value.get() == first_value[0]
assert api.config(conf).option(path, 0).value.get() == first_value[0]
assert api.forcepermissive.config(conf).option(path, 0).value.get() == first_value[0]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
assert api.forcepermissive.option(path, 0).value.get() == empty_value
raises(PropertiesOptionError, "api.config(conf).option(path, 0).value.get()")
assert api.forcepermissive.config(conf).option(path, 0).value.get() == empty_value
else:
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()")
raises(PropertiesOptionError, "api.config(conf).option(path, 0).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path, 0).value.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path).value.get() == first_value
assert api.forcepermissive.option(path).value.get() == first_value
assert api.config(conf).option(path).value.get() == first_value
assert api.forcepermissive.config(conf).option(path).value.get() == first_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.option(path).value.get()")
assert api.forcepermissive.option(path).value.get() == empty_value
raises(PropertiesOptionError, "api.config(conf).option(path).value.get()")
assert api.forcepermissive.config(conf).option(path).value.get() == empty_value
else:
raises(PropertiesOptionError, "api.option(path).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()")
raises(PropertiesOptionError, "api.config(conf).option(path).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path).value.get()")
@autocheck
def autocheck_get_value(api, path, **kwargs):
_autocheck_set_value(api, path, set_permissive=False, **kwargs)
_autocheck_get_value(api, path, **kwargs)
def autocheck_get_value(api, path, confread, confwrite, **kwargs):
_autocheck_set_value(api, path, confwrite, set_permissive=False, **kwargs)
_autocheck_get_value(api, path, confread, **kwargs)
if confread != confwrite:
_autocheck_get_value(api, path, confwrite, **kwargs)
@autocheck
def autocheck_value_slave(api, path, **kwargs):
def autocheck_value_slave(api, path, confread, confwrite, **kwargs):
isslave = api.unrestraint.option(path).option.isslave()
if not isslave:
#FIXME raises(APIError, "api.option(path).value.len()")
#FIXME raises(APIError, "api.config(confread).option(path).value.len()")
return
if kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path).value.len()")
@ -379,15 +392,19 @@ def autocheck_value_slave(api, path, **kwargs):
second_value = SUBLIST_SECOND_VALUE
empty_value = _getdefault(api, path, multi, isslave, submulti_)
if not kwargs.get('permissive', False):
length = api.option(path).value.len()
assert api.forcepermissive.option(path).value.len() == length
else:
raises(PropertiesOptionError, "api.option(path).value.len()")
length = api.forcepermissive.option(path).value.len()
assert length == 2
def do(conf):
if not kwargs.get('permissive', False):
length = api.config(conf).option(path).value.len()
assert api.forcepermissive.config(conf).option(path).value.len() == length
else:
raises(PropertiesOptionError, "api.config(conf).option(path).value.len()")
length = api.forcepermissive.config(conf).option(path).value.len()
assert length == 2
do(confread)
if confread != confwrite:
do(confwrite)
length = 2
value = []
for idx in range(length):
value.append(api.forcepermissive.option(path, idx).value.get())
@ -410,7 +427,7 @@ def autocheck_value_slave(api, path, **kwargs):
@autocheck
def autocheck_reset_value(api, path, **kwargs):
def autocheck_reset_value(api, path, confread, confwrite, **kwargs):
# check if is a multi, a master or a slave
multi = api.unrestraint.option(path).option.ismulti()
submulti_ = api.unrestraint.option(path).option.issubmulti()
@ -427,70 +444,81 @@ def autocheck_reset_value(api, path, **kwargs):
first_value = SUBLIST_FIRST_VALUE
second_value = SUBLIST_SECOND_VALUE
empty_value = _getdefault(api, path, multi, isslave, submulti_)
_autocheck_set_value(api, path, **kwargs)
_autocheck_set_value(api, path, confwrite, **kwargs)
# reset value without permissive
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.option(path).value.reset()
api.config(confwrite).option(path).value.reset()
else:
raises(PropertiesOptionError, "api.option(path).value.reset()")
raises(PropertiesOptionError, "api.config(confwrite).option(path).value.reset()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.option(path, 0).value.reset()
api.config(confwrite).option(path, 0).value.reset()
else:
raises(PropertiesOptionError, "api.option(path, 0).value.reset()")
raises(PropertiesOptionError, "api.config(confwrite).option(path, 0).value.reset()")
# get value after reset value without permissive
if isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path, 0).value.get() == empty_value
assert api.option(path, 1).value.get() == second_value[1]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
assert api.forcepermissive.option(path, 0).value.get() == empty_value
assert api.forcepermissive.option(path, 1).value.get() == second_value[1]
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path).value.get() == empty_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.option(path).value.get()")
assert api.forcepermissive.option(path).value.get() == first_value
def do(conf):
if isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(path, 0).value.get() == empty_value
assert api.config(conf).option(path, 1).value.get() == second_value[1]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.config(conf).option(path, 0).value.get()")
assert api.forcepermissive.config(conf).option(path, 0).value.get() == empty_value
assert api.forcepermissive.config(conf).option(path, 1).value.get() == second_value[1]
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(path).value.get() == empty_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.config(conf).option(path).value.get()")
assert api.forcepermissive.config(conf).option(path).value.get() == first_value
do(confread)
if confread != confwrite:
do(confwrite)
@autocheck
def autocheck_reset_value_permissive(api, path, **kwargs):
def autocheck_reset_value_permissive(api, path, confread, confwrite, **kwargs):
# check if is a multi, a master or a slave
isslave = api.unrestraint.option(path).option.isslave()
_autocheck_set_value(api, path, **kwargs)
_autocheck_set_value(api, path, confwrite, **kwargs)
# reset value with permissive
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not isslave:
api.forcepermissive.option(path).value.reset()
api.forcepermissive.config(confwrite).option(path).value.reset()
else:
api.forcepermissive.option(path, 1).value.reset()
elif kwargs.get('permissive', False):
if not isslave:
api.forcepermissive.option(path).value.reset()
api.forcepermissive.config(confwrite).option(path).value.reset()
else:
api.forcepermissive.option(path, 1).value.reset()
else:
if not isslave:
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.reset()")
raises(PropertiesOptionError, "api.forcepermissive.config(confwrite).option(path).value.reset()")
else:
raises(PropertiesOptionError, "api.forcepermissive.option(path, 1).value.reset()")
_autocheck_default_value(api, path, **kwargs)
_autocheck_default_value(api, path, confread, **kwargs)
if confread != confwrite:
_autocheck_default_value(api, path, confwrite, **kwargs)
@autocheck
def autocheck_display(api, path, **kwargs):
def autocheck_display(api, path, confread, confwrite, **kwargs):
"""re set value
"""
#FIXME make_dict?
assert api.config
_autocheck_set_value(api, path, **kwargs)
assert api.config
make_dict = kwargs['make_dict']
make_dict_value = kwargs['make_dict_value']
assert api.config(confread).config.make_dict() == make_dict
if confread != confwrite:
assert(api.config(confwrite).config.make_dict()) == make_dict
_autocheck_set_value(api, path, confwrite, **kwargs)
assert api.config(confread).config.make_dict() == make_dict_value
if confread != confwrite:
assert(api.config(confwrite).config.make_dict()) == make_dict_value
def _getproperties(multi, isslave, kwargs):
@ -508,28 +536,29 @@ def _getproperties(multi, isslave, kwargs):
return default_props, frozenset(properties)
def _check_default_properties(api, path, kwargs, props_permissive, props):
def _check_default_properties(api, path, conf, kwargs, props_permissive, props):
if not api.unrestraint.option(path).option.isslave():
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert set(api.option(path).property.get()) == set(props_permissive)
assert set(api.forcepermissive.option(path).property.get()) == set(props_permissive)
assert set(api.config(conf).option(path).property.get()) == set(props_permissive)
assert set(api.config(conf).forcepermissive.option(path).property.get()) == set(props_permissive)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path).property.get()")
assert set(api.forcepermissive.option(path).property.get()) == set(props)
raises(PropertiesOptionError, "api.config(conf).option(path).property.get()")
assert set(api.forcepermissive.config(conf).option(path).property.get()) == set(props)
else:
raises(PropertiesOptionError, "api.option(path).property.get()")
raises(PropertiesOptionError, "api.forcepermissive.option(path).property.get()")
raises(PropertiesOptionError, "api.config(conf).option(path).property.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path).property.get()")
raises(APIError, "api.unrestraint.option(path).property.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert set(api.option(path, 0).property.get()) == set(props)
assert set(api.option(path, 1).property.get()) == set(props)
assert set(api.config(conf).option(path, 0).property.get()) == set(props)
assert set(api.config(conf).option(path, 1).property.get()) == set(props)
else:
raises(PropertiesOptionError, "api.option(path, 0).property.get()")
raises(PropertiesOptionError, "api.config(conf).option(path, 0).property.get()")
raises(APIError, "api.unrestraint.option(path, 0).property.get()")
def _autocheck_property(api, path, **kwargs):
@autocheck
def autocheck_property(api, path, confread, confwrite, **kwargs):
"""get property from path
"""
# check if is a multi or a slave
@ -538,23 +567,25 @@ def _autocheck_property(api, path, **kwargs):
default_props, properties = _getproperties(multi, isslave, kwargs)
_check_default_properties(api, path, kwargs, default_props, default_props)
_check_default_properties(api, path, confread, kwargs, default_props, default_props)
_check_default_properties(api, path, confwrite, kwargs, default_props, default_props)
# set properties without permissive
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.option(path).property.set(properties)
api.config(confwrite).option(path).property.set(properties)
else:
raises(PropertiesOptionError, "api.option(path).property.set(properties)")
raises(PropertiesOptionError, "api.config(confwrite).option(path).property.set(properties)")
_check_default_properties(api, path, kwargs, properties, default_props)
_check_default_properties(api, path, confread, kwargs, properties, default_props)
if confread != confwrite:
_check_default_properties(api, path, confwrite, kwargs, properties, default_props)
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
raises(ConfigError, "api.config(confread).option(path).property.set(properties)")
@autocheck
def autocheck_property(api, path, **kwargs):
_autocheck_property(api, path, **kwargs)
def _property_permissive(api, path, **kwargs):
def _property_permissive(api, path, confread, confwrite, **kwargs):
# check if is a multi or a slave
multi = api.unrestraint.option(path).option.ismulti()
isslave = api.unrestraint.option(path).option.isslave()
@ -572,29 +603,35 @@ def _property_permissive(api, path, **kwargs):
default_props.extend(extra_properties)
default_props, properties = _getproperties(multi, isslave, kwargs)
_check_default_properties(api, path, kwargs, default_props, default_props)
_check_default_properties(api, path, confwrite, kwargs, default_props, default_props)
if confwrite != confread:
_check_default_properties(api, path, confread, kwargs, default_props, default_props)
# set properties with permissive
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.option(path).property.set(properties)
api.forcepermissive.option(path).property.set(properties)
api.config(confwrite).option(path).property.set(properties)
api.forcepermissive.config(confwrite).option(path).property.set(properties)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path).property.set(properties)")
api.forcepermissive.option(path).property.set(properties)
raises(PropertiesOptionError, "api.config(confwrite).option(path).property.set(properties)")
api.forcepermissive.config(confwrite).option(path).property.set(properties)
else:
raises(PropertiesOptionError, "api.option(path).property.set(properties)")
raises(PropertiesOptionError, "api.forcepermissive.option(path).property.set(properties)")
raises(PropertiesOptionError, "api.config(confwrite).option(path).property.set(properties)")
raises(PropertiesOptionError, "api.forcepermissive.config(confwrite).option(path).property.set(properties)")
_check_default_properties(api, path, kwargs, properties, properties)
_check_default_properties(api, path, confwrite, kwargs, properties, properties)
if confwrite != confread:
_check_default_properties(api, path, confread, kwargs, properties, properties)
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
raises(ConfigError, "api.config(confread).option(path).property.set(properties)")
@autocheck
def autocheck_property_permissive(api, path, **kwargs):
_property_permissive(api, path, **kwargs)
def autocheck_property_permissive(api, path, confread, confwrite, **kwargs):
_property_permissive(api, path, confread, confwrite, **kwargs)
@autocheck
def autocheck_reset_property(api, path, **kwargs):
def autocheck_reset_property(api, path, confread, confwrite, **kwargs):
"""check properties after set with permissive
"""
# check if is a multi or a slave
@ -602,25 +639,29 @@ def autocheck_reset_property(api, path, **kwargs):
isslave = api.unrestraint.option(path).option.isslave()
default_props, properties = _getproperties(multi, isslave, kwargs)
_property_permissive(api, path, **kwargs)
_property_permissive(api, path, confread, confwrite, **kwargs)
# reset properties without permissive
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.option(path).property.reset()
api.config(confwrite).option(path).property.reset()
else:
raises(PropertiesOptionError, "api.option(path).property.reset()")
raises(PropertiesOptionError, "api.config(confwrite).option(path).property.reset()")
_check_default_properties(api, path, kwargs, default_props, properties)
_check_default_properties(api, path, confread, kwargs, default_props, properties)
if confread != confwrite:
_check_default_properties(api, path, confwrite, kwargs, default_props, properties)
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
raises(ConfigError, "api.config(confread).option(path).property.reset()")
@autocheck
def autocheck_reset_property_permissive(api, path, **kwargs):
def autocheck_reset_property_permissive(api, path, confread, confwrite, **kwargs):
# check if is a multi or a slave
multi = api.unrestraint.option(path).option.ismulti()
isslave = api.unrestraint.option(path).option.isslave()
default_props, properties = _getproperties(multi, isslave, kwargs)
_property_permissive(api, path, **kwargs)
_property_permissive(api, path, confread, confwrite, **kwargs)
# reset properties with permissive
raises(APIError, "api.unrestraint.option(path).property.set(properties)")
@ -631,27 +672,29 @@ def autocheck_reset_property_permissive(api, path, **kwargs):
elif kwargs.get('permissive', False):
api.forcepermissive.option(path).property.reset()
_check_default_properties(api, path, kwargs, default_props, default_props)
_check_default_properties(api, path, confwrite, kwargs, default_props, default_props)
if confread != confwrite:
_check_default_properties(api, path, confread, kwargs, default_props, default_props)
@autocheck
def autocheck_context_owner(api, path, **kwargs):
def autocheck_context_owner(api, path, confread, confwrite, **kwargs):
owner = api.owner.get()
assert owner == OWNER
def _check_owner(api, path, kwargs, owner, permissive_owner):
def _check_owner(api, path, conf, kwargs, owner, permissive_owner):
isslave = api.unrestraint.option(path).option.isslave()
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path).owner.get() == owner
assert api.forcepermissive.option(path).owner.get() == owner
assert api.config(conf).option(path).owner.get() == owner
assert api.forcepermissive.config(conf).option(path).owner.get() == owner
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(path).owner.get()")
assert api.forcepermissive.option(path).owner.get() == permissive_owner
raises(PropertiesOptionError, "api.config(conf).option(path).owner.get()")
assert api.forcepermissive.config(conf).option(path).owner.get() == permissive_owner
else:
raises(PropertiesOptionError, "api.option(path).owner.get()")
raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.get()")
raises(PropertiesOptionError, "api.config(conf).option(path).owner.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path).owner.get()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path, 0).owner.get() == 'default'
@ -669,101 +712,114 @@ def _check_owner(api, path, kwargs, owner, permissive_owner):
@autocheck
def autocheck_owner_with_value(api, path, **kwargs):
def autocheck_owner_with_value(api, path, confread, confwrite, **kwargs):
"""value is now changed, check owner in this case
"""
_autocheck_set_value(api, path, **kwargs)
_check_owner(api, path, kwargs, OWNER, OWNER)
_autocheck_set_value(api, path, confwrite, **kwargs)
_check_owner(api, path, confwrite, kwargs, OWNER, OWNER)
if confread != confwrite:
_check_owner(api, path, confread, kwargs, owners.meta, owners.meta)
@autocheck
def autocheck_default_owner_with_value(api, path, **kwargs):
_autocheck_set_value(api, path, **kwargs)
# check if is a isslave
isslave = api.unrestraint.option(path).option.isslave()
def autocheck_default_owner_with_value(api, path, confread, confwrite, **kwargs):
_autocheck_set_value(api, path, confwrite, **kwargs)
# test if is default owner without permissive
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.option(path).owner.isdefault() is False
assert api.config(confwrite).option(path).owner.isdefault() is False
assert api.config(confread).option(path).owner.isdefault() is False
else:
raises(PropertiesOptionError, "api.option(path).owner.isdefault()")
raises(PropertiesOptionError, "api.config(confwrite).option(path).owner.isdefault()")
raises(PropertiesOptionError, "api.config(confread).option(path).owner.isdefault()")
@autocheck
def autocheck_default_owner_with_value_permissive(api, path, **kwargs):
def autocheck_default_owner_with_value_permissive(api, path, confread, confwrite, **kwargs):
# check if is a isslave
isslave = api.unrestraint.option(path).option.isslave()
_autocheck_set_value(api, path, **kwargs)
_autocheck_set_value(api, path, confwrite, **kwargs)
# test if is default owner with permissive
if not kwargs.get('propertyerror', False):
if not isslave:
assert api.forcepermissive.option(path).owner.isdefault() is False
def do(conf):
# test if is default owner with permissive
if not kwargs.get('propertyerror', False):
if not isslave:
assert api.forcepermissive.config(conf).option(path).owner.isdefault() is False
else:
assert api.forcepermissive.config(conf).option(path, 0).owner.isdefault() is True
assert api.forcepermissive.config(conf).option(path, 1).owner.isdefault() is False
else:
assert api.forcepermissive.option(path, 0).owner.isdefault() is True
assert api.forcepermissive.option(path, 1).owner.isdefault() is False
else:
raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.isdefault()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path).owner.isdefault()")
do(confwrite)
if confwrite != confread:
do(confread)
@autocheck
def autocheck_set_owner_no_value(api, path, **kwargs):
def autocheck_set_owner_no_value(api, path, confread, confwrite, **kwargs):
isslave = api.unrestraint.option(path).option.isslave()
if not kwargs.get('propertyerror', False):
if not isslave:
raises(ConfigError, "api.forcepermissive.option(path).owner.set('new_user')")
raises(ConfigError, "api.forcepermissive.config(confwrite).option(path).owner.set('new_user')")
else:
raises(ConfigError, "api.forcepermissive.option(path, 1).owner.set('new_user')")
@autocheck
def autocheck_set_owner(api, path, **kwargs):
def autocheck_set_owner(api, path, confread, confwrite, **kwargs):
# test set owner without permissive
isslave = api.unrestraint.option(path).option.isslave()
_autocheck_set_value(api, path, **kwargs)
_autocheck_set_value(api, path, confwrite, **kwargs)
# set owner without permissive
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.option(path).owner.set('new_user')
api.config(confwrite).option(path).owner.set('new_user')
raises(ConfigError, "api.config(confwrite).option(path).owner.set('default')")
raises(ConfigError, "api.config(confwrite).option(path).owner.set('forced')")
raises(ConfigError, "api.config(confwrite).option(path).owner.set('meta')")
else:
raises(PropertiesOptionError, "api.option(path).owner.set('new_user')")
raises(PropertiesOptionError, "api.config(confwrite).option(path).owner.set('new_user')")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.option(path, 1).owner.set('new_user')
else:
raises(PropertiesOptionError, "api.option(path, 1).owner.set('new_user')")
_check_owner(api, path, kwargs, 'new_user', OWNER)
_check_owner(api, path, confwrite, kwargs, owners.new_user, OWNER)
if confwrite != confread:
_check_owner(api, path, confread, kwargs, owners.meta, owners.meta)
@autocheck
def autocheck_set_owner_permissive(api, path, **kwargs):
def autocheck_set_owner_permissive(api, path, confread, confwrite, **kwargs):
isslave = api.unrestraint.option(path).option.isslave()
_autocheck_set_value(api, path, **kwargs)
_autocheck_set_value(api, path, confwrite, **kwargs)
# set owner with permissive
if not kwargs.get('propertyerror', False):
if not isslave:
api.forcepermissive.option(path).owner.set('new_user1')
api.forcepermissive.config(confwrite).option(path).owner.set('new_user1')
else:
api.forcepermissive.option(path, 1).owner.set('new_user1')
else:
if not isslave:
raises(PropertiesOptionError,
"api.forcepermissive.option(path).owner.set('new_user1')")
"api.forcepermissive.config(confwrite).option(path).owner.set('new_user1')")
else:
raises(PropertiesOptionError,
"api.forcepermissive.option(path, 1).owner.set('new_user1')")
_check_owner(api, path, kwargs, 'new_user1', 'new_user1')
_check_owner(api, path, confwrite, kwargs, 'new_user1', 'new_user1')
if confwrite != confread:
_check_owner(api, path, confread, kwargs, owners.meta, owners.meta)
@autocheck
def autocheck_option(api, path, **kwargs):
def autocheck_option(api, path, confread, confwrite, **kwargs):
expected_name = path.split('.')[-1]
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
current_name = api.option(path).option.getname()
@ -793,62 +849,206 @@ def autocheck_option(api, path, **kwargs):
@autocheck
def autocheck_permissive(api, path, **kwargs):
def autocheck_permissive(api, path, confread, confwrite, **kwargs):
"""test permissive for hidden and disabled value
"""
# no permissive before
assert api.unrestraint.option(path).permissive.get() == frozenset()
assert api.unrestraint.config(confread).option(path).permissive.get() == frozenset()
if kwargs.get('permissive_od', False):
assert api.unrestraint.option(path.rsplit('.', 1)[0]).permissive.get() == frozenset()
assert api.unrestraint.config(confread).option(path.rsplit('.', 1)[0]).permissive.get() == frozenset()
# cannot access to hidden value without forcepermissive
# and to disabled value (with forcepermissive too)
_autocheck_default_value(api, path, **kwargs)
#
# with meta confread == confwrite
_autocheck_default_value(api, path, confread, **kwargs)
# set permissive
api.unrestraint.option(path).permissive.set(frozenset(['disabled']))
api.unrestraint.config(confwrite).option(path).permissive.set(frozenset(['disabled']))
# have permissive
assert api.unrestraint.option(path).permissive.get() == frozenset(['disabled'])
assert api.unrestraint.config(confwrite).option(path).permissive.get() == frozenset(['disabled'])
if confwrite != confread:
assert api.unrestraint.config(confread).option(path).permissive.get() == frozenset(['disabled'])
# can access to disabled value
ckwargs = copy(kwargs)
ckwargs['propertyerror'] = False
_autocheck_default_value(api, path, **ckwargs)
_autocheck_default_value(api, path, confread, **ckwargs)
api.unrestraint.option(path).permissive.set(frozenset(['disabled', 'hidden']))
api.unrestraint.config(confwrite).option(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(api, path, **ckwargs)
_autocheck_default_value(api, path, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(api, path, confwrite, **ckwargs)
if ckwargs.get('permissive_od', False):
# set permissive to OptionDescription
api.unrestraint.option(path.rsplit('.', 1)[0]).permissive.set(frozenset(['disabled',
'hidden']))
api.unrestraint.config(confwrite).option(path.rsplit('.', 1)[0]).permissive.set(frozenset(['disabled',
'hidden']))
ckwargs['permissive'] = False
_autocheck_default_value(api, path, **ckwargs)
_autocheck_default_value(api, path, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(api, path, confwrite, **ckwargs)
# only hidden
api.unrestraint.option(path).permissive.set(frozenset(['hidden']))
api.unrestraint.config(confwrite).option(path).permissive.set(frozenset(['hidden']))
if ckwargs.get('permissive_od', False):
_autocheck_default_value(api, path, **ckwargs)
api.unrestraint.option(path.rsplit('.', 1)[0]).permissive.set(frozenset(['hidden']))
_autocheck_default_value(api, path, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(api, path, confwrite, **ckwargs)
api.unrestraint.config(confwrite).option(path.rsplit('.', 1)[0]).permissive.set(frozenset(['hidden']))
ckwargs = copy(kwargs)
ckwargs['permissive'] = False
_autocheck_default_value(api, path, **ckwargs)
_autocheck_default_value(api, path, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(api, path, confwrite, **ckwargs)
# no permissive
api.unrestraint.option(path).permissive.set(frozenset())
api.unrestraint.config(confwrite).option(path).permissive.set(frozenset())
if ckwargs.get('permissive_od', False):
_autocheck_default_value(api, path, **ckwargs)
api.unrestraint.option(path.rsplit('.', 1)[0]).permissive.set(frozenset())
_autocheck_default_value(api, path, **kwargs)
_autocheck_default_value(api, path, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(api, path, confwrite, **ckwargs)
api.unrestraint.config(confwrite).option(path.rsplit('.', 1)[0]).permissive.set(frozenset())
_autocheck_default_value(api, path, confread, **kwargs)
if confread != confwrite:
_autocheck_default_value(api, path, confwrite, **kwargs)
@autocheck
def autocheck_option_get(api, path, confread, confwrite, **kwargs):
if '.' in path:
name = path.rsplit('.', 1)[1]
else:
name = path
assert api.option.get(path).impl_getname() == name
def check_all(cfg, path, meta, multi, default, default_multi, require, consistency, **kwargs):
@autocheck
def autocheck_find(api, path, confread, confwrite, **kwargs):
def _getoption(opt):
if opt.impl_is_dynsymlinkoption():
opt = opt.impl_getopt()
return opt
def _getoptions(opts):
nopts = []
for opt in opts:
nopts.append(_getoption(opt))
return nopts
if '.' in path:
name = path.rsplit('.', 1)[1]
else:
name = path
option = _getoption(api.option.get(path))
def do(conf):
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert option == _getoption(api.config(conf).option.find_first(name))
assert option == _getoption(api.forcepermissive.config(conf).option.find_first(name))
elif kwargs.get('permissive', False):
raises(AttributeError, "api.config(conf).option.find_first(name)")
assert option == _getoption(api.forcepermissive.config(conf).option.find_first(name))
else:
raises(AttributeError, "api.config(conf).option.find_first(name)")
raises(AttributeError, "api.forcepermissive.config(conf).option.find_first(name)")
assert option == _getoption(api.unrestraint.config(conf).option.find_first(name))
assert [option] == _getoptions(api.unrestraint.config(conf).option.find(name))
assert path == api.unrestraint.config(conf).option.find_first(name, 'path')
assert [path] == api.unrestraint.config(conf).option.find(name, 'path')
do(confread)
if confread != confwrite:
do(confwrite)
def check_all(cfg, paths, path, meta, multi, default, default_multi, require, consistency, weakrefs, **kwargs):
def _build_make_dict():
dico = {}
dico_value = {}
if multi is False:
value = FIRST_VALUE
elif multi is True:
value = LIST_FIRST_VALUE
else:
value = SUBLIST_FIRST_VALUE
if not default or submulti:
if not multi:
default_value = None
else:
default_value = []
else:
default_value = value
is_dyn = False
dyns = []
has_value = False
for cpath, options in paths.items():
if options is None:
break
if '.' in cpath:
dirname, name = cpath.split('.')[-2:]
else:
dirname = ''
name = cpath
if options.get(dirname, {}).get('hidden'):
continue
if options.get(dirname, {}).get('dyn'):
is_dyn = True
no_propertieserror = not options.get(name, {}).get('disabled') and not options.get(name, {}).get('hidden')
allow_req = require and req
if is_dyn:
dyns.append(no_propertieserror or allow_req)
elif no_propertieserror or allow_req:
dico[cpath] = default_value
if path == cpath:
dico_value[cpath] = value
else:
dico_value[cpath] = default_value
has_value = True
if is_dyn:
idx = 0
for cpath in list(paths.keys())[len(dyns):]:
if dyns[idx]:
dico[cpath] = default_value
if path == cpath:
dico_value[cpath] = value
else:
dico_value[cpath] = default_value
idx += 1
if idx == len(dyns):
idx = 0
if require:
if not req:
dico['extraoptrequire'] = None
dico_value['extraoptrequire'] = None
else:
dico['extraoptrequire'] = 'value'
dico_value['extraoptrequire'] = 'value'
if consistency and has_value:
cpath = list(dico.keys())[0]
if "." in cpath:
cpath = cpath.rsplit('.', 1)[0] + '.'
else:
cpath = ''
if multi:
value = []
else:
value = None
if is_dyn:
dico[cpath + 'extraoptconsistencyval1'] = value
dico[cpath[:-2] + '2.' + 'extraoptconsistencyval2'] = value
dico_value[cpath + 'extraoptconsistencyval1'] = value
dico_value[cpath[:-2] + '2.' + 'extraoptconsistencyval2'] = value
else:
dico[cpath + 'extraoptconsistency'] = value
dico_value[cpath + 'extraoptconsistency'] = value
return dico, dico_value
if DISPLAY:
text = u' {} launch tests for {}'.format(ICON, path)
if multi is True:
@ -861,19 +1061,33 @@ def check_all(cfg, path, meta, multi, default, default_multi, require, consisten
text += u' with default value'
if default_multi is True:
text += u' with default multi'
if require:
text += u' with requirement'
if consistency:
text += u' with consistency'
text += u', kwargs: {}'.format(kwargs)
print(text)
api = getapi(cfg)
if api.unrestraint.option(path).option.isslave():
master_path = path.rsplit('.', 1)[0] + '.master'
api.option(master_path).value.set(LIST_SECOND_VALUE)
if not require:
requires = [False]
else:
requires = [False, True]
confwrite = confread = None
idx = 0
for req in requires:
kwargs['make_dict'], kwargs['make_dict_value'] = _build_make_dict()
for func in autocheck_registers:
api = getapi(cfg.duplicate())
cfg_name = 'conftest' + str(idx)
idx += 1
ncfg = cfg.duplicate(session_id=cfg_name)
if meta:
confwrite = None
confread = cfg_name
ncfg = MetaConfig([ncfg], session_id='metatest')
weakrefs.append(weakref.ref(cfg))
api = getapi(ncfg)
if api.unrestraint.option(path).option.isslave():
master_path = path.rsplit('.', 1)[0] + '.master'
api.option(master_path).value.set(LIST_SECOND_VALUE)
#FIXME devrait etre dans la config ca ...
api.read_write()
ckwargs = copy(kwargs)
@ -887,7 +1101,7 @@ def check_all(cfg, path, meta, multi, default, default_multi, require, consisten
if DISPLAY:
print(u' {} {}'.format(ICON, func.__name__))
try:
func(api, path, **ckwargs)
func(api, path, confread, confwrite, **ckwargs)
except Exception as err:
msg = u'error in function {} for {}'.format(func.__name__, path)
if multi is True:
@ -898,6 +1112,8 @@ def check_all(cfg, path, meta, multi, default, default_multi, require, consisten
msg += u' with default value'
print(u'{}: {}'.format(msg, ckwargs))
raise err
del api
del ncfg
def check_deref(weakrefs):
@ -1027,9 +1243,6 @@ def make_conf(options, meta, multi, default, default_multi, require, consistency
return None, None
cfg = Config(rootod, session_id='conftest')
weakrefs.append(weakref.ref(cfg))
if meta:
cfg = MetaConfig([cfg], session_id='metatest')
weakrefs.append(weakref.ref(cfg))
del goptions
return cfg, weakrefs, dyn
@ -1056,7 +1269,7 @@ DICT_PATHS = [
OrderedDict([('odmaster.first', {'master': {'master': True}}),
('odmaster.second', {'second': {'disabled': True, 'slave': True}}),
('odmaster.third', {'third': {'hidden': True, 'slave': True}})]),
##test a config with dynoption
#test a config with dynoption
OrderedDict([('subod.first', {'subod': {'dyn': True}}),
('subod.second', {'second': {'disabled': True}}),
('subod.third', {'third': {'hidden': True}}),
@ -1124,35 +1337,34 @@ def test_options(paths):
return kwargs
lpaths = list(paths.keys())
meta = False
#for meta in (False, True):
for consistency in (False, True):
for require in (False, True):
for default_multi in (False, True):
for default in (False, True):
for multi in (False, True, submulti):
if multi is submulti and consistency:
continue
if multi is False and default_multi:
continue
cfg, weakrefs, dyn = make_conf(paths, meta, multi, default, default_multi, require, consistency)
if cfg is None:
continue
if dyn:
cnt = 0
idx = 0
for index, lpath in enumerate(lpaths):
if paths[lpath]:
cnt += 1
else:
check_all(cfg, lpaths[index], meta, multi, default,
default_multi, require, consistency, **get_kwargs(lpaths[idx]))
idx += 1
if idx == cnt:
idx = 0
else:
for lpath in lpaths:
check_all(cfg, lpath, meta, multi, default,
default_multi, require, consistency, **get_kwargs(lpath))
del cfg
check_deref(weakrefs)
for meta in (False, True):
for consistency in (False, True):
for require in (False, True):
for default_multi in (False, True):
for default in (False, True):
for multi in (False, True, submulti):
if multi is submulti and consistency:
continue
if multi is False and default_multi:
continue
cfg, weakrefs, dyn = make_conf(paths, meta, multi, default, default_multi, require, consistency)
if cfg is None:
continue
if dyn:
cnt = 0
idx = 0
for index, lpath in enumerate(lpaths):
if paths[lpath]:
cnt += 1
else:
check_all(cfg, paths, lpaths[index], meta, multi, default,
default_multi, require, consistency, weakrefs, **get_kwargs(lpaths[idx]))
idx += 1
if idx == cnt:
idx = 0
else:
for lpath in lpaths:
check_all(cfg, paths, lpath, meta, multi, default,
default_multi, require, consistency, weakrefs, **get_kwargs(lpath))
del cfg
check_deref(weakrefs)