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

remove getapi in tests

Browse Source
This commit is contained in:
Emmanuel Garette
2018-08-14 23:07:07 +02:00
parent a37a37cc44
commit 6b6fa5e499
23 changed files with 1205 additions and 1392 deletions
Download Patch File Download Diff File Expand all files Collapse all files

909
test/auto/test_auto.py
View File

@ -8,7 +8,7 @@ from .autopath import do_autopath
do_autopath()
from tiramisu import Config, MetaConfig, \
StrOption, SymLinkOption, OptionDescription, MasterSlaves, DynOptionDescription, \
getapi, submulti, undefined, owners, Params, ParamOption
submulti, undefined, owners, Params, ParamOption
from tiramisu.error import PropertiesOptionError, APIError, ConfigError, SlaveError
from collections import OrderedDict
ICON = u'\u2937'
@ -70,97 +70,97 @@ def autocheck(func):
@autocheck
def autocheck_option_multi(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_option_multi(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.option(pathread).option.ismulti()
api.option(pathread).option.issubmulti()
api.option(pathread).option.ismaster()
api.option(pathread).option.isslave()
cfg.option(pathread).option.ismulti()
cfg.option(pathread).option.issubmulti()
cfg.option(pathread).option.ismaster()
cfg.option(pathread).option.isslave()
else:
raises(PropertiesOptionError, "api.option(pathread).option.ismulti()")
raises(PropertiesOptionError, "api.option(pathread).option.issubmulti()")
raises(PropertiesOptionError, "api.option(pathread).option.ismaster()")
raises(PropertiesOptionError, "api.option(pathread).option.isslave()")
raises(PropertiesOptionError, "cfg.option(pathread).option.ismulti()")
raises(PropertiesOptionError, "cfg.option(pathread).option.issubmulti()")
raises(PropertiesOptionError, "cfg.option(pathread).option.ismaster()")
raises(PropertiesOptionError, "cfg.option(pathread).option.isslave()")
if not kwargs.get('propertyerror', False):
api.forcepermissive.option(pathread).option.ismulti()
api.forcepermissive.option(pathread).option.issubmulti()
api.forcepermissive.option(pathread).option.ismaster()
api.forcepermissive.option(pathread).option.isslave()
cfg.forcepermissive.option(pathread).option.ismulti()
cfg.forcepermissive.option(pathread).option.issubmulti()
cfg.forcepermissive.option(pathread).option.ismaster()
cfg.forcepermissive.option(pathread).option.isslave()
else:
raises(PropertiesOptionError, "api.forcepermissive.option(pathread).option.ismulti()")
raises(PropertiesOptionError, "api.forcepermissive.option(pathread).option.issubmulti()")
raises(PropertiesOptionError, "api.forcepermissive.option(pathread).option.ismaster()")
raises(PropertiesOptionError, "api.forcepermissive.option(pathread).option.isslave()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.ismulti()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.issubmulti()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.ismaster()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.isslave()")
api.unrestraint.option(pathread).option.ismulti()
api.unrestraint.option(pathread).option.issubmulti()
api.unrestraint.option(pathread).option.ismaster()
api.unrestraint.option(pathread).option.isslave()
cfg.unrestraint.option(pathread).option.ismulti()
cfg.unrestraint.option(pathread).option.issubmulti()
cfg.unrestraint.option(pathread).option.ismaster()
cfg.unrestraint.option(pathread).option.isslave()
@autocheck
def autocheck_default_owner(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_default_owner(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""check different value of owner when any value is set to this option
"""
isslave = api.unrestraint.option(pathread).option.isslave()
isslave = cfg.unrestraint.option(pathread).option.isslave()
# check if owner is a string "default" and 'isdefault'
def do(conf):
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(pathread).owner.get() == 'default'
assert api.forcepermissive.config(conf).option(pathread).owner.get() == 'default'
assert cfg.config(conf).option(pathread).owner.get() == 'default'
assert cfg.forcepermissive.config(conf).option(pathread).owner.get() == 'default'
#
assert api.config(conf).option(pathread).owner.isdefault()
assert api.forcepermissive.config(conf).option(pathread).owner.isdefault()
assert cfg.config(conf).option(pathread).owner.isdefault()
assert cfg.forcepermissive.config(conf).option(pathread).owner.isdefault()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.config(conf).option(pathread).owner.get()")
assert api.forcepermissive.config(conf).option(pathread).owner.get() == 'default'
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.get()")
assert cfg.forcepermissive.config(conf).option(pathread).owner.get() == 'default'
#
raises(PropertiesOptionError, "api.config(conf).option(pathread).owner.isdefault()")
assert api.forcepermissive.config(conf).option(pathread).owner.isdefault()
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.isdefault()")
assert cfg.forcepermissive.config(conf).option(pathread).owner.isdefault()
else:
raises(PropertiesOptionError, "api.config(conf).option(pathread).owner.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread).owner.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).owner.get()")
#
raises(PropertiesOptionError, "api.config(conf).option(pathread).owner.isdefault()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread).owner.isdefault()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.isdefault()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).owner.isdefault()")
#
assert api.unrestraint.config(conf).option(pathread).owner.get() == 'default'
assert api.unrestraint.config(conf).option(pathread).owner.isdefault()
assert cfg.unrestraint.config(conf).option(pathread).owner.get() == 'default'
assert cfg.unrestraint.config(conf).option(pathread).owner.isdefault()
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(pathread, 0).owner.get() == 'default'
assert api.forcepermissive.config(conf).option(pathread, 0).owner.get() == 'default'
assert cfg.config(conf).option(pathread, 0).owner.get() == 'default'
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.get() == 'default'
#
assert api.config(conf).option(pathread, 0).owner.isdefault()
assert api.forcepermissive.config(conf).option(pathread, 0).owner.isdefault()
assert cfg.config(conf).option(pathread, 0).owner.isdefault()
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.isdefault()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.config(conf).option(pathread, 0).owner.get()")
assert api.forcepermissive.config(conf).option(pathread, 0).owner.get() == 'default'
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.get()")
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.get() == 'default'
#
raises(PropertiesOptionError, "api.config(conf).option(pathread, 0).owner.isdefault()")
assert api.forcepermissive.config(conf).option(pathread, 0).owner.isdefault()
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.isdefault()")
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.isdefault()
else:
raises(PropertiesOptionError, "api.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread, 0).owner.get()")
#
raises(PropertiesOptionError, "api.config(conf).option(pathread, 0).owner.isdefault()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread, 0).owner.isdefault()")
assert api.unrestraint.config(conf).option(pathread, 0).owner.get() == 'default'
assert api.unrestraint.config(conf).option(pathread, 0).owner.isdefault()
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()
do(confread)
if confread != confwrite:
do(confwrite)
def _autocheck_default_value(api, path, conf, **kwargs):
def _autocheck_default_value(cfg, path, conf, **kwargs):
"""set and get values
"""
# check if is a multi, a master or a slave
multi = api.unrestraint.option(path).option.ismulti()
submulti_ = api.unrestraint.option(path).option.issubmulti()
isslave = api.unrestraint.option(path).option.isslave()
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']
@ -169,43 +169,43 @@ def _autocheck_default_value(api, path, conf, **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.config(conf).option(path).value.get() == empty_value
assert api.forcepermissive.config(conf).option(path).value.get() == empty_value
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, "api.config(conf).option(path).value.get()")
assert api.forcepermissive.config(conf).option(path).value.get() == empty_value
raises(PropertiesOptionError, "cfg.config(conf).option(path).value.get()")
assert cfg.forcepermissive.config(conf).option(path).value.get() == empty_value
else:
raises(PropertiesOptionError, "api.config(conf).option(path).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path).value.get()")
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 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
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, "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
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, "api.config(conf).option(path, 0).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(path, 0).value.get()")
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(api, pathread, pathwrite, confread, confwrite, **kwargs):
_autocheck_default_value(api, pathread, confread, **kwargs)
def autocheck_default_value(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
_autocheck_default_value(cfg, pathread, confread, **kwargs)
if confread != confwrite:
_autocheck_default_value(api, pathread, confwrite, **kwargs)
_autocheck_default_value(cfg, pathread, confwrite, **kwargs)
def _set_value(api, pathwrite, conf, **kwargs):
def _set_value(cfg, pathwrite, conf, **kwargs):
set_permissive = kwargs.get('set_permissive', True)
multi = api.unrestraint.option(pathwrite).option.ismulti()
submulti_ = api.unrestraint.option(pathwrite).option.issubmulti()
ismaster = api.unrestraint.option(pathwrite).option.ismaster()
isslave = api.unrestraint.option(pathwrite).option.isslave()
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:
@ -224,65 +224,65 @@ def _set_value(api, pathwrite, conf, **kwargs):
# for master must append, not set
if ismaster:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
raises(APIError, "api.config(conf).option(pathwrite, 0).value.set(first_value[0])")
raises(APIError, "cfg.config(conf).option(pathwrite, 0).value.set(first_value[0])")
if not set_permissive:
api.config(conf).option(pathwrite).value.set([first_value[0]])
cfg.config(conf).option(pathwrite).value.set([first_value[0]])
else:
api.forcepermissive.config(conf).option(pathwrite).value.set([first_value[0]])
cfg.forcepermissive.config(conf).option(pathwrite).value.set([first_value[0]])
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.config(conf).option(pathwrite).value.set([first_value[0]])")
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set([first_value[0]])")
if set_permissive:
api.forcepermissive.config(conf).option(pathwrite).value.set([first_value[0]])
cfg.forcepermissive.config(conf).option(pathwrite).value.set([first_value[0]])
else:
raises(PropertiesOptionError, "api.config(conf).option(pathwrite).value.set([first_value[0]])")
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set([first_value[0]])")
raises(PropertiesOptionError,
"api.forcepermissive.config(conf).option(pathwrite).value.set([first_value[0]])")
"cfg.forcepermissive.config(conf).option(pathwrite).value.set([first_value[0]])")
if len(first_value) > 1:
raises(APIError, "api.unrestraint.config(conf).option(pathwrite).value.set(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:
api.config(conf).option(pathwrite, 1).value.set(second_value)
cfg.config(conf).option(pathwrite, 1).value.set(second_value)
else:
api.forcepermissive.config(conf).option(pathwrite, 1).value.set(second_value)
cfg.forcepermissive.config(conf).option(pathwrite, 1).value.set(second_value)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.config(conf).option(pathwrite, 1).value.set(second_value)")
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite, 1).value.set(second_value)")
if set_permissive:
api.forcepermissive.config(conf).option(pathwrite, 1).value.set(second_value)
cfg.forcepermissive.config(conf).option(pathwrite, 1).value.set(second_value)
else:
raises(PropertiesOptionError, "api.config(conf).option(pathwrite, 1).value.set(second_value)")
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite, 1).value.set(second_value)")
raises(PropertiesOptionError,
"api.forcepermissive.config(conf).option(pathwrite, 1).value.set(second_value)")
"cfg.forcepermissive.config(conf).option(pathwrite, 1).value.set(second_value)")
raises(APIError,
"api.unrestraint.config(conf).option(pathwrite).value.set([second_value, second_value])")
"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:
api.config(conf).option(pathwrite).value.set(first_value)
cfg.config(conf).option(pathwrite).value.set(first_value)
else:
api.forcepermissive.config(conf).option(pathwrite).value.set(first_value)
cfg.forcepermissive.config(conf).option(pathwrite).value.set(first_value)
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.config(conf).option(pathwrite).value.set(first_value)")
raises(PropertiesOptionError, "cfg.config(conf).option(pathwrite).value.set(first_value)")
if set_permissive:
api.forcepermissive.config(conf).option(pathwrite).value.set(first_value)
cfg.forcepermissive.config(conf).option(pathwrite).value.set(first_value)
else:
raises(PropertiesOptionError, "api.config(conf).option(pathwrite).value.set(first_value)")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathwrite).value.set(first_value)")
#FIXME raises(APIError, "api.unrestraint.config(conf).option(pathwrite).value.set(first_value)")
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(api, pathread, pathwrite, confread, confwrite, **kwargs):
_set_value(api, pathwrite, confwrite, **kwargs)
def autocheck_set_value(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
_set_value(cfg, pathwrite, confwrite, **kwargs)
@autocheck
def autocheck_get_value_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs):
multi = api.unrestraint.option(pathread).option.ismulti()
submulti_ = api.unrestraint.option(pathread).option.issubmulti()
isslave = api.unrestraint.option(pathread).option.isslave()
_set_value(api, pathwrite, confwrite, **kwargs)
def autocheck_get_value_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
multi = cfg.unrestraint.option(pathread).option.ismulti()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
isslave = cfg.unrestraint.option(pathread).option.isslave()
_set_value(cfg, pathwrite, confwrite, **kwargs)
empty_value = kwargs['default']
if not multi:
first_value = FIRST_VALUE
@ -295,47 +295,47 @@ def autocheck_get_value_permissive(api, pathread, pathwrite, confread, confwrite
# 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(pathread, 0).value.get() == empty_value
assert api.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
assert cfg.config(conf).option(pathread, 0).value.get() == empty_value
assert cfg.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
if submulti_:
assert api.config(conf).option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1]
assert api.forcepermissive.config(conf).option(pathread, 1).value.get() == SUBLIST_SECOND_VALUE[1]
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]
else:
assert api.config(conf).option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
assert api.forcepermissive.config(conf).option(pathread, 1).value.get() == LIST_SECOND_VALUE[1]
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]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "assert api.config(conf).option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert api.config(conf).option(pathread, 1).value.get()")
assert api.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
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
if submulti_:
assert api.forcepermissive.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]
else:
assert api.forcepermissive.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]
else:
raises(PropertiesOptionError, "assert api.config(conf).option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert api.config(conf).option(pathread, 1).value.get()")
raises(PropertiesOptionError, "assert api.forcepermissive.config(conf).option(pathread, 0).value.get()")
raises(PropertiesOptionError, "assert api.forcepermissive.config(conf).option(pathread, 1).value.get()")
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()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(pathread).value.get() == first_value
assert api.forcepermissive.config(conf).option(pathread).value.get() == first_value
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, "api.config(conf).option(pathread).value.get()")
assert api.forcepermissive.config(conf).option(pathread).value.get() == first_value
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
assert cfg.forcepermissive.config(conf).option(pathread).value.get() == first_value
else:
raises(PropertiesOptionError, "api.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).value.get()")
do(confread)
if confread != confwrite:
do(confwrite)
def _autocheck_get_value(api, pathread, conf, **kwargs):
def _autocheck_get_value(cfg, pathread, conf, **kwargs):
set_permissive = kwargs.get('set_permissive', True)
multi = api.unrestraint.option(pathread).option.ismulti()
submulti_ = api.unrestraint.option(pathread).option.issubmulti()
isslave = api.unrestraint.option(pathread).option.isslave()
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
@ -354,71 +354,71 @@ def _autocheck_get_value(api, pathread, conf, **kwargs):
# 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(pathread, 0).value.get() == empty_value
assert api.config(conf).option(pathread, 1).value.get() == second_value
assert api.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
assert api.forcepermissive.config(conf).option(pathread, 1).value.get() == second_value
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, "api.config(conf).option(pathread, 0).value.get()")
assert api.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
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 api.forcepermissive.config(conf).option(pathread, 1).value.get() == second_value
assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get() == second_value
else:
assert api.forcepermissive.config(conf).option(pathread, 1).value.get() == empty_value
assert cfg.forcepermissive.config(conf).option(pathread, 1).value.get() == empty_value
else:
raises(PropertiesOptionError, "api.config(conf).option(pathread, 0).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread, 0).value.get()")
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 api.config(conf).option(pathread).value.get() == first_value
assert api.forcepermissive.config(conf).option(pathread).value.get() == first_value
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, "api.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
if set_permissive:
assert api.forcepermissive.config(conf).option(pathread).value.get() == first_value
assert cfg.forcepermissive.config(conf).option(pathread).value.get() == first_value
else:
assert api.forcepermissive.config(conf).option(pathread).value.get() == empty_value
assert cfg.forcepermissive.config(conf).option(pathread).value.get() == empty_value
else:
raises(PropertiesOptionError, "api.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).value.get()")
@autocheck
def autocheck_get_value(api, pathread, pathwrite, confread, confwrite, **kwargs):
_set_value(api, pathwrite, confwrite, set_permissive=False, **kwargs)
_autocheck_get_value(api, pathread, confread, set_permissive=False, **kwargs)
def autocheck_get_value(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
_set_value(cfg, pathwrite, confwrite, set_permissive=False, **kwargs)
_autocheck_get_value(cfg, pathread, confread, set_permissive=False, **kwargs)
if pathread.endswith('val1'):
val2_path = pathread.replace('val1', 'val2')
_autocheck_default_value(api, val2_path, confread, **kwargs)
_autocheck_default_value(cfg, val2_path, confread, **kwargs)
if confread != confwrite:
_autocheck_get_value(api, pathread, confwrite, set_permissive=False, **kwargs)
_autocheck_get_value(cfg, pathread, confwrite, set_permissive=False, **kwargs)
if pathread.endswith('val1'):
_autocheck_default_value(api, val2_path, confwrite, **kwargs)
_autocheck_default_value(cfg, val2_path, confwrite, **kwargs)
@autocheck
def autocheck_value_slave(api, pathread, pathwrite, confread, confwrite, **kwargs):
isslave = api.unrestraint.option(pathread).option.isslave()
def autocheck_value_slave(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
isslave = cfg.unrestraint.option(pathread).option.isslave()
if not isslave:
if kwargs.get('propertyerror', False):
raises(APIError, "api.unrestraint.config(confread).option(pathread).value.len()")
raises(APIError, "cfg.unrestraint.config(confread).option(pathread).value.len()")
return
if kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(pathread).value.len()")
raises(PropertiesOptionError, "api.forcepermissive.option(pathread).value.len()")
raises(PropertiesOptionError, "cfg.option(pathread).value.len()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).value.len()")
return
multi = api.unrestraint.option(pathread).option.ismulti()
submulti_ = api.forcepermissive.option(pathread).option.issubmulti()
multi = cfg.unrestraint.option(pathread).option.ismulti()
submulti_ = cfg.forcepermissive.option(pathread).option.issubmulti()
empty_value = kwargs['default']
def do(conf):
if not kwargs.get('permissive', False):
length = api.config(conf).option(pathread).value.len()
assert api.forcepermissive.config(conf).option(pathread).value.len() == length
length = cfg.config(conf).option(pathread).value.len()
assert cfg.forcepermissive.config(conf).option(pathread).value.len() == length
else:
raises(PropertiesOptionError, "api.config(conf).option(pathread).value.len()")
length = api.forcepermissive.config(conf).option(pathread).value.len()
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.len()")
length = cfg.forcepermissive.config(conf).option(pathread).value.len()
assert length == 2
do(confread)
if confread != confwrite:
@ -427,7 +427,7 @@ def autocheck_value_slave(api, pathread, pathwrite, confread, confwrite, **kwarg
length = 2
value = []
for idx in range(length):
value.append(api.forcepermissive.option(pathread, idx).value.get())
value.append(cfg.forcepermissive.option(pathread, idx).value.get())
assert value == [empty_value, empty_value]
# cannot access to a slave with index too high
@ -436,22 +436,22 @@ def autocheck_value_slave(api, pathread, pathwrite, confread, confwrite, **kwarg
else:
value = SUBLIST_FIRST_VALUE[0]
raises(SlaveError, "api.forcepermissive.option(pathread, length).value.get()")
raises(SlaveError, "api.forcepermissive.option(pathread, length).value.set(value)")
raises(SlaveError, "api.forcepermissive.option(pathread, length).value.reset()")
raises(SlaveError, "api.forcepermissive.option(pathread, length).owner.get()")
raises(SlaveError, "api.forcepermissive.option(pathread, length).owner.isdefault()")
raises(SlaveError, "api.forcepermissive.option(pathread, length).property.get()")
raises(SlaveError, "api.forcepermissive.option(pathread, length).owner.set('new_user')")
raises(SlaveError, "api.forcepermissive.option(pathread, length).property.add('prop')")
raises(SlaveError, "cfg.forcepermissive.option(pathread, length).value.get()")
raises(SlaveError, "cfg.forcepermissive.option(pathread, length).value.set(value)")
raises(SlaveError, "cfg.forcepermissive.option(pathread, length).value.reset()")
raises(SlaveError, "cfg.forcepermissive.option(pathread, length).owner.get()")
raises(SlaveError, "cfg.forcepermissive.option(pathread, length).owner.isdefault()")
raises(SlaveError, "cfg.forcepermissive.option(pathread, length).property.get()")
raises(SlaveError, "cfg.forcepermissive.option(pathread, length).owner.set('new_user')")
raises(SlaveError, "cfg.forcepermissive.option(pathread, length).property.add('prop')")
@autocheck
def autocheck_reset_value(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_reset_value(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi, a master or a slave
multi = api.unrestraint.option(pathread).option.ismulti()
submulti_ = api.unrestraint.option(pathread).option.issubmulti()
isslave = api.unrestraint.option(pathread).option.isslave()
multi = cfg.unrestraint.option(pathread).option.ismulti()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
isslave = cfg.unrestraint.option(pathread).option.isslave()
# set default value (different if value is multi or not)
if not multi:
@ -464,55 +464,55 @@ def autocheck_reset_value(api, pathread, pathwrite, confread, confwrite, **kwarg
first_value = SUBLIST_FIRST_VALUE
second_value = SUBLIST_SECOND_VALUE
empty_value = kwargs['default']
_set_value(api, pathwrite, confwrite, **kwargs)
_set_value(cfg, pathwrite, confwrite, **kwargs)
# reset value without permissive
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.config(confwrite).option(pathwrite).value.reset()
cfg.config(confwrite).option(pathwrite).value.reset()
#else:
#FIXME raises(PropertiesOptionError, "api.config(confwrite).option(pathwrite).value.reset()")
#FIXME raises(PropertiesOptionError, "cfg.config(confwrite).option(pathwrite).value.reset()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.config(confwrite).option(pathwrite, 0).value.reset()
cfg.config(confwrite).option(pathwrite, 0).value.reset()
#else:
#FIXME raises(PropertiesOptionError, "api.config(confwrite).option(pathwrite, 0).value.reset()")
#FIXME raises(PropertiesOptionError, "cfg.config(confwrite).option(pathwrite, 0).value.reset()")
# get value after reset value without permissive
def do(conf):
if isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(pathread, 0).value.get() == empty_value
assert api.config(conf).option(pathread, 1).value.get() == second_value[1]
assert cfg.config(conf).option(pathread, 0).value.get() == empty_value
assert cfg.config(conf).option(pathread, 1).value.get() == second_value[1]
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.config(conf).option(pathread, 0).value.get()")
assert api.forcepermissive.config(conf).option(pathread, 0).value.get() == empty_value
assert api.forcepermissive.config(conf).option(pathread, 1).value.get() == second_value[1]
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]
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(conf).option(pathread).value.get() == empty_value
assert cfg.config(conf).option(pathread).value.get() == empty_value
elif kwargs.get('permissive', False):
raises(PropertiesOptionError, "api.config(conf).option(pathread).value.get()")
assert api.forcepermissive.config(conf).option(pathread).value.get() == first_value
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).value.get()")
assert cfg.forcepermissive.config(conf).option(pathread).value.get() == first_value
do(confread)
if confread != confwrite:
do(confwrite)
@autocheck
def autocheck_append_value(api, pathread, pathwrite, confread, confwrite, **kwargs):
ismaster = api.unrestraint.option(pathread).option.ismaster()
submulti_ = api.unrestraint.option(pathread).option.issubmulti()
def autocheck_append_value(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
ismaster = cfg.unrestraint.option(pathread).option.ismaster()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
if not ismaster:
return
if not kwargs.get('propertyerror', False):
master_value = api.forcepermissive.config(confread).option(pathread).value.get()
master_value = cfg.forcepermissive.config(confread).option(pathread).value.get()
len_value = len(master_value)
master_value.append(undefined)
assert len(api.forcepermissive.config(confread).option(pathread).value.get()) == len_value
api.forcepermissive.config(confwrite).option(pathread).value.set(master_value)
new_master_value = api.forcepermissive.config(confread).option(pathread).value.get()
assert len(cfg.forcepermissive.config(confread).option(pathread).value.get()) == len_value
cfg.forcepermissive.config(confwrite).option(pathread).value.set(master_value)
new_master_value = cfg.forcepermissive.config(confread).option(pathread).value.get()
len_new = len(new_master_value)
assert len_value + 1 == len_new
assert new_master_value[-1] == kwargs['default_multi']
@ -522,22 +522,22 @@ def autocheck_append_value(api, pathread, pathwrite, confread, confwrite, **kwar
else:
slave_path += '.third'
for idx in range(len_new):
assert api.forcepermissive.config(confread).option(slave_path, idx).value.get() == kwargs['default_multi']
assert cfg.forcepermissive.config(confread).option(slave_path, idx).value.get() == kwargs['default_multi']
#
if not submulti_:
value = 'value'
else:
value = ['value']
master_value.append(value)
assert len(api.forcepermissive.config(confread).option(pathread).value.get()) == len(new_master_value)
api.forcepermissive.config(confwrite).option(pathread).value.set(master_value)
assert api.forcepermissive.config(confread).option(pathread).value.get()[-1] == value
assert len(cfg.forcepermissive.config(confread).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
@autocheck
def autocheck_pop_value(api, pathread, pathwrite, confread, confwrite, **kwargs):
ismaster = api.unrestraint.option(pathread).option.ismaster()
submulti_ = api.unrestraint.option(pathread).option.issubmulti()
def autocheck_pop_value(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
ismaster = cfg.unrestraint.option(pathread).option.ismaster()
submulti_ = cfg.unrestraint.option(pathread).option.issubmulti()
if not ismaster:
return
@ -554,77 +554,77 @@ def autocheck_pop_value(api, pathread, pathwrite, confread, confwrite, **kwargs)
a_slave += '.third' + a_slave[-4:]
else:
a_slave += '.third'
api.forcepermissive.config(confwrite).option(pathread).value.set(values)
api.forcepermissive.config(confwrite).option(a_slave, 1).value.set(slave_value)
api.forcepermissive.config(confread).option(a_slave, 0).value.get() == kwargs['default_multi']
assert api.forcepermissive.config(confread).option(a_slave, 0).owner.isdefault() is True
api.forcepermissive.config(confread).option(a_slave, 1).value.get() == slave_value
assert api.forcepermissive.config(confread).option(a_slave, 1).owner.isdefault() is False
api.forcepermissive.config(confread).option(a_slave, 2).value.get() == kwargs['default_multi']
assert api.forcepermissive.config(confread).option(a_slave, 2).owner.isdefault() is True
api.forcepermissive.config(confread).option(a_slave, 3).value.get() == kwargs['default_multi']
assert api.forcepermissive.config(confread).option(a_slave, 3).owner.isdefault() is True
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
#
api.forcepermissive.config(confwrite).option(pathread).value.pop(3)
api.forcepermissive.config(confread).option(a_slave, 0).value.get() == kwargs['default_multi']
assert api.forcepermissive.config(confread).option(a_slave, 0).owner.isdefault() is True
api.forcepermissive.config(confread).option(a_slave, 1).value.get() == slave_value
assert api.forcepermissive.config(confread).option(a_slave, 1).owner.isdefault() is False
api.forcepermissive.config(confread).option(a_slave, 2).value.get() == kwargs['default_multi']
assert api.forcepermissive.config(confread).option(a_slave, 2).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
#
api.forcepermissive.config(confwrite).option(pathread).value.pop(0)
api.forcepermissive.config(confread).option(a_slave, 0).value.get() == slave_value
assert api.forcepermissive.config(confread).option(a_slave, 0).owner.isdefault() is False
api.forcepermissive.config(confread).option(a_slave, 1).value.get() == kwargs['default_multi']
assert api.forcepermissive.config(confread).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() == 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
#
api.forcepermissive.config(confwrite).option(pathread).value.pop(0)
api.forcepermissive.config(confread).option(a_slave, 0).value.get() == kwargs['default_multi']
assert api.forcepermissive.config(confread).option(a_slave, 0).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
@autocheck
def autocheck_reset_value_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_reset_value_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi, a master or a slave
isslave = api.unrestraint.option(pathread).option.isslave()
_set_value(api, pathwrite, confwrite, **kwargs)
isslave = cfg.unrestraint.option(pathread).option.isslave()
_set_value(cfg, pathwrite, confwrite, **kwargs)
# reset value with permissive
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
if not isslave:
api.forcepermissive.config(confwrite).option(pathwrite).value.reset()
cfg.forcepermissive.config(confwrite).option(pathwrite).value.reset()
else:
api.forcepermissive.option(pathwrite, 1).value.reset()
cfg.forcepermissive.option(pathwrite, 1).value.reset()
elif kwargs.get('permissive', False):
if not isslave:
api.forcepermissive.config(confwrite).option(pathwrite).value.reset()
cfg.forcepermissive.config(confwrite).option(pathwrite).value.reset()
else:
api.forcepermissive.option(pathwrite, 1).value.reset()
cfg.forcepermissive.option(pathwrite, 1).value.reset()
#FIXME else:
# if not isslave:
# raises(PropertiesOptionError, "api.forcepermissive.config(confwrite).option(pathwrite).value.reset()")
# raises(PropertiesOptionError, "cfg.forcepermissive.config(confwrite).option(pathwrite).value.reset()")
# else:
# raises(PropertiesOptionError, "api.forcepermissive.option(pathwrite, 1).value.reset()")
_autocheck_default_value(api, pathread, confread, **kwargs)
# raises(PropertiesOptionError, "cfg.forcepermissive.option(pathwrite, 1).value.reset()")
_autocheck_default_value(cfg, pathread, confread, **kwargs)
if confread != confwrite:
_autocheck_default_value(api, pathwrite, confwrite, **kwargs)
_autocheck_default_value(cfg, pathwrite, confwrite, **kwargs)
@autocheck
def autocheck_display(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_display(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""re set value
"""
if kwargs['callback']:
return
make_dict = kwargs['make_dict']
make_dict_value = kwargs['make_dict_value']
assert api.config(confread).option.make_dict() == make_dict
assert cfg.config(confread).option.make_dict() == make_dict
if confread != confwrite:
assert(api.config(confwrite).option.make_dict()) == make_dict
_set_value(api, pathwrite, confwrite, **kwargs)
assert api.config(confread).option.make_dict() == make_dict_value
assert(cfg.config(confwrite).option.make_dict()) == make_dict
_set_value(cfg, pathwrite, confwrite, **kwargs)
assert cfg.config(confread).option.make_dict() == make_dict_value
if confread != confwrite:
assert(api.config(confwrite).option.make_dict()) == make_dict_value
assert(cfg.config(confwrite).option.make_dict()) == make_dict_value
def _getproperties(multi, isslave, kwargs):
@ -642,81 +642,81 @@ def _getproperties(multi, isslave, kwargs):
return default_props, frozenset(properties)
def _check_properties(api, pathread, conf, kwargs, props_permissive, props):
if not api.unrestraint.option(pathread).option.isslave():
def _check_properties(cfg, 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(api.config(conf).option(pathread).property.get()) == set(props_permissive)
assert set(api.config(conf).option(pathread).property.get()) == set(props)
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, "api.config(conf).option(pathread).property.get()")
raises(PropertiesOptionError, "api.config(conf).option(pathread).property.get()")
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(api.forcepermissive.config(conf).option(pathread).property.get()) == set(props_permissive)
assert set(api.forcepermissive.config(conf).option(pathread).property.get()) == set(props)
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, "api.forcepermissive.config(conf).option(pathread).property.get()"
assert PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread).property.get()"
assert set(api.unrestraint.config(conf).option(pathread).property.get()) == set(props_permissive)
assert set(api.unrestraint.config(conf).option(pathread).property.get()) == set(props)
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(api.config(conf).option(pathread, 0).property.get()) == set(props_permissive)
assert set(api.config(conf).option(pathread, 0).property.get()) == set(props)
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(api.config(conf).option(pathread, 1).property.get()) == set(props_permissive)
assert set(api.config(conf).option(pathread, 1).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, "api.config(conf).option(pathread, 0).property.get()")
raises(PropertiesOptionError, "api.config(conf).option(pathread, 0).property.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).property.get()")
raises(PropertiesOptionError, "cfg.config(conf).option(pathread, 0).property.get()")
#
raises(PropertiesOptionError, "api.config(conf).option(pathread, 1).property.get()")
raises(PropertiesOptionError, "api.config(conf).option(pathread, 1).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(api.forcepermissive.config(conf).option(pathread, 0).property.get()) == set(props_permissive)
assert set(api.forcepermissive.config(conf).option(pathread, 0).property.get()) == set(props)
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(api.forcepermissive.config(conf).option(pathread, 1).property.get()) == set(props_permissive)
assert set(api.forcepermissive.config(conf).option(pathread, 1).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, "api.forcepermissive.config(conf).option(pathread, 0).property.get()")
raises(PropertiesOptionError, "api.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, 0).property.get()")
#
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread, 1).property.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread, 1).property.get()")
assert set(api.unrestraint.config(conf).option(pathread, 0).property.get()) == set(props_permissive)
assert set(api.unrestraint.config(conf).option(pathread, 0).property.get()) == set(props)
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(api.unrestraint.config(conf).option(pathread, 1).property.get()) == set(props_permissive)
assert set(api.unrestraint.config(conf).option(pathread, 1).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(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_property(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""get property from path
"""
# check if is a multi or a slave
multi = api.unrestraint.option(pathread).option.ismulti()
isslave = api.unrestraint.option(pathread).option.isslave()
multi = cfg.unrestraint.option(pathread).option.ismulti()
isslave = cfg.unrestraint.option(pathread).option.isslave()
default_props, properties = _getproperties(multi, isslave, kwargs)
_check_properties(api, pathread, confread, kwargs, default_props, default_props)
_check_properties(cfg, pathread, confread, kwargs, default_props, default_props)
if confread != confwrite:
_check_properties(api, pathread, confwrite, kwargs, default_props, default_props)
_check_properties(cfg, pathread, confwrite, kwargs, default_props, default_props)
# set properties without permissive
for prop in properties:
api.unrestraint.config(confwrite).option(pathwrite).property.add(prop)
_check_properties(api, pathread, confread, kwargs, properties, properties)
cfg.unrestraint.config(confwrite).option(pathwrite).property.add(prop)
_check_properties(cfg, pathread, confread, kwargs, properties, properties)
if confread != confwrite:
_check_properties(api, pathread, confwrite, kwargs, properties, properties)
_check_properties(cfg, pathread, confwrite, kwargs, properties, properties)
def _property_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs):
def _property_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi or a slave
multi = api.unrestraint.option(pathread).option.ismulti()
isslave = api.unrestraint.option(pathread).option.isslave()
multi = cfg.unrestraint.option(pathread).option.ismulti()
isslave = cfg.unrestraint.option(pathread).option.isslave()
# define properties
properties = copy(PROPERTIES_LIST)
@ -731,243 +731,243 @@ def _property_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs
default_props.extend(extra_properties)
default_props, properties = _getproperties(multi, isslave, kwargs)
_check_properties(api, pathread, confwrite, kwargs, default_props, default_props)
_check_properties(cfg, pathread, confwrite, kwargs, default_props, default_props)
if confwrite != confread:
_check_properties(api, pathread, confread, kwargs, default_props, default_props)
_check_properties(cfg, 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):
api.config(confwrite).option(pathwrite).property.add(prop)
cfg.config(confwrite).option(pathwrite).property.add(prop)
if not kwargs.get('propertyerror', False):
api.forcepermissive.config(confwrite).option(pathwrite).property.add(prop)
api.unrestraint.config(confwrite).option(pathwrite).property.add(prop)
cfg.forcepermissive.config(confwrite).option(pathwrite).property.add(prop)
cfg.unrestraint.config(confwrite).option(pathwrite).property.add(prop)
_check_properties(api, pathread, confwrite, kwargs, properties, properties)
_check_properties(cfg, pathread, confwrite, kwargs, properties, properties)
if confwrite != confread:
_check_properties(api, pathread, confread, kwargs, properties, properties)
_check_properties(cfg, pathread, confread, kwargs, properties, properties)
@autocheck
def autocheck_property_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs):
_property_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs)
def autocheck_property_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
_property_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs)
@autocheck
def autocheck_reset_property(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_reset_property(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""check properties after set with permissive
"""
# check if is a multi or a slave
multi = api.unrestraint.option(pathread).option.ismulti()
isslave = api.unrestraint.option(pathread).option.isslave()
multi = cfg.unrestraint.option(pathread).option.ismulti()
isslave = cfg.unrestraint.option(pathread).option.isslave()
default_props, properties = _getproperties(multi, isslave, kwargs)
_property_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs)
_property_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs)
# reset properties without permissive
api.unrestraint.config(confwrite).option(pathwrite).property.reset()
cfg.unrestraint.config(confwrite).option(pathwrite).property.reset()
_check_properties(api, pathread, confread, kwargs, default_props, default_props)
_check_properties(cfg, pathread, confread, kwargs, default_props, default_props)
if confread != confwrite:
_check_properties(api, pathread, confwrite, kwargs, default_props, default_props)
_check_properties(cfg, pathread, confwrite, kwargs, default_props, default_props)
@autocheck
def autocheck_reset_property_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_reset_property_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a multi or a slave
multi = api.unrestraint.option(pathread).option.ismulti()
isslave = api.unrestraint.option(pathread).option.isslave()
multi = cfg.unrestraint.option(pathread).option.ismulti()
isslave = cfg.unrestraint.option(pathread).option.isslave()
default_props, properties = _getproperties(multi, isslave, kwargs)
_property_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs)
_property_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs)
for prop in properties:
api.unrestraint.option(pathwrite).property.add(prop)
api.unrestraint.option(pathwrite).property.reset()
cfg.unrestraint.option(pathwrite).property.add(prop)
cfg.unrestraint.option(pathwrite).property.reset()
_check_properties(api, pathread, confwrite, kwargs, default_props, default_props)
_check_properties(cfg, pathread, confwrite, kwargs, default_props, default_props)
if confread != confwrite:
_check_properties(api, pathread, confread, kwargs, default_props, default_props)
_check_properties(cfg, pathread, confread, kwargs, default_props, default_props)
@autocheck
def autocheck_context_owner(api, pathread, pathwrite, confread, confwrite, **kwargs):
owner = api.owner.get()
def autocheck_context_owner(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
owner = cfg.owner.get()
assert owner == kwargs['owner']
def _check_owner(api, pathread, conf, kwargs, owner, permissive_owner):
isslave = api.unrestraint.option(pathread).option.isslave()
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 api.config(conf).option(pathread).owner.get() == owner
assert api.forcepermissive.config(conf).option(pathread).owner.get() == owner
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, "api.config(conf).option(pathread).owner.get()")
assert api.forcepermissive.config(conf).option(pathread).owner.get() == permissive_owner
raises(PropertiesOptionError, "cfg.config(conf).option(pathread).owner.get()")
assert cfg.forcepermissive.config(conf).option(pathread).owner.get() == permissive_owner
else:
raises(PropertiesOptionError, "api.config(conf).option(pathread).owner.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread).owner.get()")
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 api.config(conf).option(pathread, 0).owner.get() == 'default'
assert api.forcepermissive.config(conf).option(pathread, 0).owner.get() == 'default'
assert api.config(conf).option(pathread, 1).owner.get() == owner
assert api.forcepermissive.config(conf).option(pathread, 1).owner.get() == owner
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, "api.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "api.config(conf).option(pathread, 1).owner.get()")
assert api.forcepermissive.config(conf).option(pathread, 0).owner.get() == 'default'
assert api.forcepermissive.config(conf).option(pathread, 1).owner.get() == permissive_owner
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, "api.config(conf).option(pathread, 0).owner.get()")
raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread, 0).owner.get()")
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(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_owner_with_value(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""value is now changed, check owner in this case
"""
_set_value(api, pathwrite, confwrite, **kwargs)
_check_owner(api, pathread, confwrite, kwargs, kwargs['owner'], kwargs['owner'])
_set_value(cfg, pathwrite, confwrite, **kwargs)
_check_owner(cfg, pathread, confwrite, kwargs, kwargs['owner'], kwargs['owner'])
if confread != confwrite:
_check_owner(api, pathread, confread, kwargs, kwargs['owner'], kwargs['owner'])
_check_owner(cfg, pathread, confread, kwargs, kwargs['owner'], kwargs['owner'])
@autocheck
def autocheck_default_owner_with_value(api, pathread, pathwrite, confread, confwrite, **kwargs):
isslave = api.unrestraint.option(pathread).option.isslave()
_set_value(api, pathwrite, confwrite, **kwargs)
def autocheck_default_owner_with_value(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
isslave = cfg.unrestraint.option(pathread).option.isslave()
_set_value(cfg, pathwrite, confwrite, **kwargs)
# test if is default owner without permissive
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(confwrite).option(pathread).owner.isdefault() is False
assert cfg.config(confwrite).option(pathread).owner.isdefault() is False
if confwrite != confread:
assert api.config(confread).option(pathread).owner.isdefault() is False
assert cfg.config(confread).option(pathread).owner.isdefault() is False
#FIXME else:
# raises(PropertiesOptionError, "api.config(confwrite).option(pathread).owner.isdefault()")
# raises(PropertiesOptionError, "api.config(confread).option(pathread).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathread).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confread).option(pathread).owner.isdefault()")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert api.config(confwrite).option(pathread, 0).owner.isdefault() is True
assert api.config(confwrite).option(pathread, 1).owner.isdefault() is False
assert cfg.config(confwrite).option(pathread, 0).owner.isdefault() is True
assert cfg.config(confwrite).option(pathread, 1).owner.isdefault() is False
if confwrite != confread:
assert api.config(confread).option(pathread, 0).owner.isdefault() is True
assert api.config(confread).option(pathread, 1).owner.isdefault() is False
assert cfg.config(confread).option(pathread, 0).owner.isdefault() is True
assert cfg.config(confread).option(pathread, 1).owner.isdefault() is False
#FIXME else:
# raises(PropertiesOptionError, "api.config(confwrite).option(pathread, 0).owner.isdefault()")
# raises(PropertiesOptionError, "api.config(confread).option(pathread, 0).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathread, 0).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.config(confread).option(pathread, 0).owner.isdefault()")
@autocheck
def autocheck_default_owner_with_value_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_default_owner_with_value_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
# check if is a isslave
isslave = api.unrestraint.option(pathread).option.isslave()
isslave = cfg.unrestraint.option(pathread).option.isslave()
_set_value(api, pathwrite, confwrite, **kwargs)
_set_value(cfg, pathwrite, confwrite, **kwargs)
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(pathread).owner.isdefault() is False
assert cfg.forcepermissive.config(conf).option(pathread).owner.isdefault() is False
else:
assert api.forcepermissive.config(conf).option(pathread, 0).owner.isdefault() is True
assert api.forcepermissive.config(conf).option(pathread, 1).owner.isdefault() is False
assert cfg.forcepermissive.config(conf).option(pathread, 0).owner.isdefault() is True
assert cfg.forcepermissive.config(conf).option(pathread, 1).owner.isdefault() is False
#FIXME else:
# raises(PropertiesOptionError, "api.forcepermissive.config(conf).option(pathread).owner.isdefault()")
# raises(PropertiesOptionError, "cfg.forcepermissive.config(conf).option(pathread).owner.isdefault()")
do(confwrite)
if confwrite != confread:
do(confread)
@autocheck
def autocheck_set_owner_no_value(api, pathread, pathwrite, confread, confwrite, **kwargs):
isslave = api.unrestraint.option(pathread).option.isslave()
def autocheck_set_owner_no_value(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
isslave = cfg.unrestraint.option(pathread).option.isslave()
if not kwargs.get('propertyerror', False):
if not isslave:
raises(ConfigError, "api.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user')")
raises(ConfigError, "cfg.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user')")
else:
raises(ConfigError, "api.forcepermissive.option(pathwrite, 1).owner.set('new_user')")
raises(ConfigError, "cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user')")
@autocheck
def autocheck_set_owner(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_set_owner(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
# test set owner without permissive
isslave = api.unrestraint.option(pathread).option.isslave()
isslave = cfg.unrestraint.option(pathread).option.isslave()
_set_value(api, pathwrite, confwrite, **kwargs)
_set_value(cfg, pathwrite, confwrite, **kwargs)
# set owner without permissive
if not isslave:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.config(confwrite).option(pathwrite).owner.set('new_user')
raises(ConfigError, "api.config(confwrite).option(pathwrite).owner.set('default')")
raises(ConfigError, "api.config(confwrite).option(pathwrite).owner.set('forced')")
raises(ConfigError, "api.config(confwrite).option(pathwrite).owner.set('meta')")
cfg.config(confwrite).option(pathwrite).owner.set('new_user')
raises(ConfigError, "cfg.config(confwrite).option(pathwrite).owner.set('default')")
raises(ConfigError, "cfg.config(confwrite).option(pathwrite).owner.set('forced')")
raises(ConfigError, "cfg.config(confwrite).option(pathwrite).owner.set('meta')")
#FIXME else:
# raises(PropertiesOptionError, "api.config(confwrite).option(pathwrite).owner.set('new_user')")
# raises(PropertiesOptionError, "cfg.config(confwrite).option(pathwrite).owner.set('new_user')")
else:
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
api.option(pathwrite, 1).owner.set('new_user')
cfg.option(pathwrite, 1).owner.set('new_user')
#FIXME else:
# raises(PropertiesOptionError, "api.option(pathwrite, 1).owner.set('new_user')")
# raises(PropertiesOptionError, "cfg.option(pathwrite, 1).owner.set('new_user')")
_check_owner(api, pathread, confwrite, kwargs, owners.new_user, kwargs['owner'])
_check_owner(cfg, pathread, confwrite, kwargs, owners.new_user, kwargs['owner'])
if confwrite != confread:
_check_owner(api, pathread, confread, kwargs, owners.new_user, owners.meta)
_check_owner(cfg, pathread, confread, kwargs, owners.new_user, owners.meta)
@autocheck
def autocheck_set_owner_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs):
isslave = api.unrestraint.option(pathread).option.isslave()
def autocheck_set_owner_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
isslave = cfg.unrestraint.option(pathread).option.isslave()
_set_value(api, pathwrite, confwrite, **kwargs)
_set_value(cfg, pathwrite, confwrite, **kwargs)
# set owner with permissive
if not kwargs.get('propertyerror', False):
if not isslave:
api.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user1')
cfg.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user1')
else:
api.forcepermissive.option(pathwrite, 1).owner.set('new_user1')
cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user1')
#FIXME else:
# if not isslave:
# raises(PropertiesOptionError,
# "api.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user1')")
# "cfg.forcepermissive.config(confwrite).option(pathwrite).owner.set('new_user1')")
# else:
# raises(PropertiesOptionError,
# "api.forcepermissive.option(pathwrite, 1).owner.set('new_user1')")
# "cfg.forcepermissive.option(pathwrite, 1).owner.set('new_user1')")
_check_owner(api, pathread, confwrite, kwargs, 'new_user1', 'new_user1')
_check_owner(cfg, pathread, confwrite, kwargs, 'new_user1', 'new_user1')
if confwrite != confread:
_check_owner(api, pathread, confread, kwargs, 'new_user1', 'new_user1')
_check_owner(cfg, pathread, confread, kwargs, 'new_user1', 'new_user1')
@autocheck
def autocheck_option(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_option(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
expected_name = pathread.split('.')[-1]
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
current_name = api.option(pathread).option.name()
assert current_name == api.forcepermissive.option(pathread).option.name()
assert current_name == api.unrestraint.option(pathread).option.name()
doc = api.option(pathread).option.doc()
assert doc == api.forcepermissive.option(pathread).option.doc()
assert doc == api.unrestraint.option(pathread).option.doc()
current_name = cfg.option(pathread).option.name()
assert current_name == cfg.forcepermissive.option(pathread).option.name()
assert current_name == cfg.unrestraint.option(pathread).option.name()
doc = cfg.option(pathread).option.doc()
assert doc == cfg.forcepermissive.option(pathread).option.doc()
assert doc == cfg.unrestraint.option(pathread).option.doc()
elif not kwargs.get('propertyerror', False):
raises(PropertiesOptionError, "api.option(pathread).option.name()")
current_name = api.forcepermissive.option(pathread).option.name()
assert current_name == api.unrestraint.option(pathread).option.name()
raises(PropertiesOptionError, "api.option(pathread).option.doc()")
doc = api.forcepermissive.option(pathread).option.doc()
assert doc == api.unrestraint.option(pathread).option.doc()
raises(PropertiesOptionError, "cfg.option(pathread).option.name()")
current_name = cfg.forcepermissive.option(pathread).option.name()
assert current_name == cfg.unrestraint.option(pathread).option.name()
raises(PropertiesOptionError, "cfg.option(pathread).option.doc()")
doc = cfg.forcepermissive.option(pathread).option.doc()
assert doc == cfg.unrestraint.option(pathread).option.doc()
else:
raises(PropertiesOptionError, "api.option(pathread).option.name()")
raises(PropertiesOptionError, "api.forcepermissive.option(pathread).option.name()")
current_name = api.unrestraint.option(pathread).option.name()
raises(PropertiesOptionError, "api.option(pathread).option.doc()")
raises(PropertiesOptionError, "api.forcepermissive.option(pathread).option.doc()")
doc = api.unrestraint.option(pathread).option.doc()
raises(PropertiesOptionError, "cfg.option(pathread).option.name()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.name()")
current_name = cfg.unrestraint.option(pathread).option.name()
raises(PropertiesOptionError, "cfg.option(pathread).option.doc()")
raises(PropertiesOptionError, "cfg.forcepermissive.option(pathread).option.doc()")
doc = cfg.unrestraint.option(pathread).option.doc()
assert current_name == expected_name
if expected_name.endswith('val1') or expected_name.endswith('val2'):
expected_name = expected_name[:-4]
@ -978,100 +978,100 @@ def autocheck_option(api, pathread, pathwrite, confread, confwrite, **kwargs):
@autocheck
def autocheck_permissive(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_permissive(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
"""test permissive for hidden and disabled value
"""
# no permissive before
assert api.unrestraint.config(confread).option(pathread).permissive.get() == frozenset()
assert cfg.unrestraint.config(confread).option(pathread).permissive.get() == frozenset()
if kwargs.get('permissive_od', False):
assert api.unrestraint.config(confread).option(pathread.rsplit('.', 1)[0]).permissive.get() == frozenset()
assert cfg.unrestraint.config(confread).option(pathread.rsplit('.', 1)[0]).permissive.get() == frozenset()
# cannot access to hidden value without forcepermissive
# and to disabled value (with forcepermissive too)
#
# with meta confread == confwrite
_autocheck_default_value(api, pathread, confread, **kwargs)
_autocheck_default_value(cfg, pathread, confread, **kwargs)
# set permissive
api.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset(['disabled']))
cfg.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset(['disabled']))
callback = kwargs['callback']
if callback:
if pathread.endswith('val1') or pathread.endswith('val2'):
call_path = pathread[:-4] + 'call' + pathread[-4:]
else:
call_path = pathread + 'call'
api.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset(['disabled']))
cfg.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset(['disabled']))
# have permissive
assert api.unrestraint.config(confwrite).option(pathread).permissive.get() == frozenset(['disabled'])
assert cfg.unrestraint.config(confwrite).option(pathread).permissive.get() == frozenset(['disabled'])
if confwrite != confread:
assert api.unrestraint.config(confread).option(pathread).permissive.get() == frozenset(['disabled'])
assert cfg.unrestraint.config(confread).option(pathread).permissive.get() == frozenset(['disabled'])
# can access to disabled value
ckwargs = copy(kwargs)
ckwargs['propertyerror'] = False
_autocheck_default_value(api, pathread, confread, **ckwargs)
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
api.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset(['disabled', 'hidden']))
cfg.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset(['disabled', 'hidden']))
if kwargs['callback']:
api.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset(['disabled', 'hidden']))
cfg.unrestraint.config(confwrite).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(api, pathread, confread, **ckwargs)
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(api, pathread, confwrite, **ckwargs)
_autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
if ckwargs.get('permissive_od', False):
# set permissive to OptionDescription
api.unrestraint.config(confwrite).option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset(['disabled',
cfg.unrestraint.config(confwrite).option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset(['disabled',
'hidden']))
ckwargs['permissive'] = False
_autocheck_default_value(api, pathread, confread, **ckwargs)
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(api, pathread, confwrite, **ckwargs)
_autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
# only hidden
api.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset(['hidden']))
cfg.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset(['hidden']))
if callback:
api.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset(['hidden']))
cfg.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset(['hidden']))
if ckwargs.get('permissive_od', False):
_autocheck_default_value(api, pathread, confread, **ckwargs)
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(api, pathread, confwrite, **ckwargs)
api.unrestraint.config(confwrite).option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset(['hidden']))
_autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
cfg.unrestraint.config(confwrite).option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset(['hidden']))
ckwargs = copy(kwargs)
ckwargs['permissive'] = False
_autocheck_default_value(api, pathread, confread, **ckwargs)
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(api, pathread, confwrite, **ckwargs)
_autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
# no permissive
api.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset())
cfg.unrestraint.config(confwrite).option(pathwrite).permissive.set(frozenset())
if callback:
api.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset())
cfg.unrestraint.config(confwrite).option(call_path).permissive.set(frozenset())
if ckwargs.get('permissive_od', False):
_autocheck_default_value(api, pathread, confread, **ckwargs)
_autocheck_default_value(cfg, pathread, confread, **ckwargs)
if confread != confwrite:
_autocheck_default_value(api, pathread, confwrite, **ckwargs)
api.unrestraint.config(confwrite).option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset())
_autocheck_default_value(api, pathread, confread, **kwargs)
_autocheck_default_value(cfg, pathread, confwrite, **ckwargs)
cfg.unrestraint.config(confwrite).option(pathwrite.rsplit('.', 1)[0]).permissive.set(frozenset())
_autocheck_default_value(cfg, pathread, confread, **kwargs)
if confread != confwrite:
_autocheck_default_value(api, pathread, confwrite, **kwargs)
_autocheck_default_value(cfg, pathread, confwrite, **kwargs)
@autocheck
def autocheck_option_get(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_option_get(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
if '.' in pathread:
name = pathread.rsplit('.', 1)[1]
else:
name = pathread
assert api.unrestraint.option(pathread).option.name() == name
assert cfg.unrestraint.option(pathread).option.name() == name
@autocheck
def autocheck_find(api, pathread, pathwrite, confread, confwrite, **kwargs):
def autocheck_find(cfg, pathread, pathwrite, confread, confwrite, **kwargs):
def _getoption(opt):
opt = opt.option.get()
if opt.impl_is_dynsymlinkoption():
@ -1088,20 +1088,20 @@ def autocheck_find(api, pathread, pathwrite, confread, confwrite, **kwargs):
name = pathread.rsplit('.', 1)[1]
else:
name = pathread
option = _getoption(api.unrestraint.option(pathread))
option = _getoption(cfg.unrestraint.option(pathread))
def do(conf):
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
assert option == _getoption(api.config(conf).option.find(name, first=True))
assert option == _getoption(api.forcepermissive.config(conf).option.find(name, first=True))
assert option == _getoption(cfg.config(conf).option.find(name, first=True))
assert option == _getoption(cfg.forcepermissive.config(conf).option.find(name, first=True))
elif kwargs.get('permissive', False):
raises(AttributeError, "api.config(conf).option.find(name, first=True)")
assert option == _getoption(api.forcepermissive.config(conf).option.find(name, first=True))
raises(AttributeError, "cfg.config(conf).option.find(name, first=True)")
assert option == _getoption(cfg.forcepermissive.config(conf).option.find(name, first=True))
else:
raises(AttributeError, "api.config(conf).option.find(name, first=True)")
raises(AttributeError, "api.forcepermissive.config(conf).option.find(name, first=True)")
assert option == _getoption(api.unrestraint.config(conf).option.find(name, first=True))
assert [option] == _getoptions(api.unrestraint.config(conf).option.find(name))
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))
do(confread)
if confread != confwrite:
do(confwrite)
@ -1310,15 +1310,14 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
confread = cfg_name
ncfg = MetaConfig([ncfg], session_id='metatest')
weakrefs.append(weakref.ref(cfg))
api = getapi(ncfg)
ckwargs = copy(kwargs)
if meta:
api.owner.set('meta')
ncfg.owner.set('meta')
ckwargs['owner'] = owners.meta
else:
ckwargs['owner'] = OWNER
if api.unrestraint.option(path).option.isslave():
if ncfg.unrestraint.option(path).option.isslave():
dirname = path.rsplit('.', 1)[0]
master_path = dirname + '.first'
master_path_2 = None
@ -1330,14 +1329,14 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
value = SUBLIST_SECOND_VALUE
else:
value = LIST_SECOND_VALUE
api.option(master_path).value.set(value)
ncfg.option(master_path).value.set(value)
ckwargs['make_dict'][master_path] = value
ckwargs['make_dict_value'][master_path] = value
if symlink:
ckwargs['make_dict'][master_path + 'link'] = value
ckwargs['make_dict_value'][master_path + 'link'] = value
if master_path_2:
api.option(master_path_2).value.set(value)
ncfg.option(master_path_2).value.set(value)
ckwargs['make_dict'][master_path_2] = value
ckwargs['make_dict_value'][master_path_2] = value
if symlink:
@ -1393,13 +1392,12 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
do('val1', 'val2')
do('val2', 'val1')
#FIXME devrait etre dans la config ca ...
api.property.read_write()
ncfg.property.read_write()
if req:
name = 'extraoptrequire'
if symlink:
name += 'link'
api.option(name).value.set('value')
ncfg.option(name).value.set('value')
if 'permissive' in ckwargs and not 'permissive_od' in ckwargs or \
'propertyerror' in ckwargs and not 'propertyerror_od' in ckwargs:
for to_del in ['permissive', 'propertyerror', 'extra_properties']:
@ -1413,7 +1411,7 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
else:
pathwrite = path
try:
func(api, pathread, pathwrite, confread, confwrite, **ckwargs)
func(ncfg, pathread, pathwrite, confread, confwrite, **ckwargs)
except Exception as err:
msg = u'error in function {} for {}'.format(func.__name__, path)
if multi is True:
@ -1428,7 +1426,6 @@ def check_all(cfg, paths_, path, meta, multi, default, default_multi, require, c
msg += u' (symlink)'
print(u'{}: {}'.format(msg, ckwargs))
raise err
del api
del ncfg