diff --git a/test/api/test_owner.py b/test/api/test_owner.py index 6fa9739..428db6a 100644 --- a/test/api/test_owner.py +++ b/test/api/test_owner.py @@ -2,13 +2,14 @@ """ import weakref import pytest +from copy import copy from py.test import raises from .autopath import do_autopath do_autopath() from tiramisu import Config, MetaConfig, \ StrOption, OptionDescription, MasterSlaves, DynOptionDescription, \ getapi, submulti, undefined -from tiramisu.error import PropertiesOptionError, APIError +from tiramisu.error import PropertiesOptionError, APIError, ConfigError from collections import OrderedDict ICON = u'\u2937' @@ -16,6 +17,7 @@ OPTIONS_TYPE = {'str': {'type': str, 'option': StrOption} } PROPERTIES = ['hidden', 'disabled'] +PROPERTIES_LIST = ['prop1', 'prop2'] OWNER = 'user' @@ -33,7 +35,7 @@ SUBLIST_SECOND_VALUE = [['myvalue'], ['myvalue1', 'myvalue2']] SUBLIST_EMPTY_VALUE = [] DISPLAY = True -#DISPLAY = False +DISPLAY = False def return_list(val=None, suffix=None): @@ -64,52 +66,103 @@ def autocheck(func): @autocheck -def autocheck_owner_without_value(api, path, **kwargs): +def autocheck_option_multi(api, path, **kwargs): + if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): + api.option(path).option.ismulti() + api.option(path).option.issubmulti() + api.option(path).option.ismaster() + api.option(path).option.isslave() + # + api.forcepermissive.option(path).option.ismulti() + api.forcepermissive.option(path).option.issubmulti() + api.forcepermissive.option(path).option.ismaster() + api.forcepermissive.option(path).option.isslave() + # + api.unrestraint.option(path).option.ismulti() + api.unrestraint.option(path).option.issubmulti() + api.unrestraint.option(path).option.ismaster() + api.unrestraint.option(path).option.isslave() + elif not kwargs.get('propertyerror', False): + raises(PropertiesOptionError, "api.option(path).option.ismulti()") + raises(PropertiesOptionError, "api.option(path).option.issubmulti()") + raises(PropertiesOptionError, "api.option(path).option.ismaster()") + raises(PropertiesOptionError, "api.option(path).option.isslave()") + # + api.forcepermissive.option(path).option.ismulti() + api.forcepermissive.option(path).option.issubmulti() + api.forcepermissive.option(path).option.ismaster() + api.forcepermissive.option(path).option.isslave() + # + api.unrestraint.option(path).option.ismulti() + api.unrestraint.option(path).option.issubmulti() + api.unrestraint.option(path).option.ismaster() + api.unrestraint.option(path).option.isslave() + else: + raises(PropertiesOptionError, "api.option(path).option.ismulti()") + raises(PropertiesOptionError, "api.option(path).option.issubmulti()") + raises(PropertiesOptionError, "api.option(path).option.ismaster()") + raises(PropertiesOptionError, "api.option(path).option.isslave()") + # + raises(PropertiesOptionError, "api.forcepermissive.option(path).option.ismulti()") + raises(PropertiesOptionError, "api.forcepermissive.option(path).option.issubmulti()") + raises(PropertiesOptionError, "api.forcepermissive.option(path).option.ismaster()") + raises(PropertiesOptionError, "api.forcepermissive.option(path).option.isslave()") + # + api.unrestraint.option(path).option.ismulti() + api.unrestraint.option(path).option.issubmulti() + api.unrestraint.option(path).option.ismaster() + api.unrestraint.option(path).option.isslave() + + +@autocheck +def autocheck_default_owner(api, path, **kwargs): """check different value of owner when any value is set to this option """ - try: - isslave = api.forcepermissive.option(path).option.isslave() - except: - isslave = False - # check if owner is a string "default" - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if not isslave: + 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' - else: - assert api.option(path, 0).owner.get() == 'default' - else: - if not isslave: - raises(PropertiesOptionError, "api.option(path).owner.get()") - else: - raises(PropertiesOptionError, "api.option(path, 0).owner.get()") - raises(APIError, "api.unrestraint.option(path).owner.get()") - if not kwargs.get('propertyerror', False): - if not isslave: assert api.forcepermissive.option(path).owner.get() == 'default' - else: - assert api.forcepermissive.option(path, 0).owner.get() == 'default' - else: - if not isslave: - raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.get()") - else: - raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.get()") - - # check if default owner - raises(APIError, "api.unrestraint.option(path).owner.isdefault()") - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if not isslave: + # assert api.option(path).owner.isdefault() - else: - assert api.option(path, 0).owner.isdefault() - else: - raises(PropertiesOptionError, "api.option(path).owner.isdefault()") - if not kwargs.get('propertyerror', False): - if not isslave: + 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() else: - assert api.forcepermissive.option(path, 0).owner.isdefault() + 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: - raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.isdefault()") + 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()") + + # unrestraint is not allowed + raises(APIError, "api.unrestraint.option(path).owner.get()") + raises(APIError, "api.unrestraint.option(path).owner.isdefault()") + def _getdefault(api, path, multi, isslave, submulti_): empty_value = api.unrestraint.option(path).option.getdefault() @@ -117,181 +170,239 @@ def _getdefault(api, path, multi, isslave, submulti_): empty_value = api.unrestraint.option(path).option.getdefaultmulti() return empty_value -@autocheck -def autocheck_value(api, path, **kwargs): + +def _autocheck_default_value(api, path, **kwargs): """set and get values """ # check if is a multi, a master or a slave - if not kwargs.get('propertyerror', False): - multi = api.forcepermissive.option(path).option.ismulti() - submulti_ = api.forcepermissive.option(path).option.issubmulti() - ismaster = api.forcepermissive.option(path).option.ismaster() - isslave = api.forcepermissive.option(path).option.isslave() - else: - raises(PropertiesOptionError, "api.forcepermissive.option(path).option.ismulti()") - multi = api.unrestraint.option(path).option.ismulti() - submulti_ = api.unrestraint.option(path).option.issubmulti() - ismaster = api.unrestraint.option(path).option.ismaster() - isslave = api.unrestraint.option(path).option.isslave() + multi = api.unrestraint.option(path).option.ismulti() + submulti_ = api.unrestraint.option(path).option.issubmulti() + isslave = api.unrestraint.option(path).option.isslave() # set default value (different if value is multi or not) - if not multi: - first_value = FIRST_VALUE - second_value = SECOND_VALUE - elif submulti_ is False: - first_value = LIST_FIRST_VALUE - second_value = LIST_SECOND_VALUE - else: - first_value = SUBLIST_FIRST_VALUE - second_value = SUBLIST_SECOND_VALUE empty_value = _getdefault(api, path, multi, isslave, submulti_) - # test default value (should be empty) without permissive + # test default value (should be empty) # 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 - else: + assert api.forcepermissive.option(path).value.get() == empty_value + elif not kwargs.get('propertyerror', False): raises(PropertiesOptionError, "api.option(path).value.get()") - - # test default value (should be empty) with permissive - # cannot test for slave (we cannot get all values for a slave) - raises(APIError, "api.unrestraint.option(path).value.get()") - if not isslave: - if not kwargs.get('propertyerror', False): assert api.forcepermissive.option(path).value.get() == empty_value else: + raises(PropertiesOptionError, "api.option(path).value.get()") raises(PropertiesOptionError, "api.forcepermissive.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 + 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 + else: + raises(PropertiesOptionError, "api.option(path, 0).value.get()") + raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()") + + +@autocheck +def autocheck_default_value(api, path, **kwargs): + _autocheck_default_value(api, path, **kwargs) + + +def _autocheck_set_value(api, path, **kwargs): + set_permissive = kwargs.get('set_permissive', True) + multi = api.unrestraint.option(path).option.ismulti() + submulti_ = api.unrestraint.option(path).option.issubmulti() + ismaster = api.unrestraint.option(path).option.ismaster() + isslave = api.unrestraint.option(path).option.isslave() +# empty_value = _getdefault(api, path, multi, isslave, submulti_) + if not multi: + first_value = FIRST_VALUE +# second_value = SECOND_VALUE + elif submulti_ is False: + first_value = LIST_FIRST_VALUE +# second_value = LIST_SECOND_VALUE + else: + first_value = SUBLIST_FIRST_VALUE +# second_value = SUBLIST_SECOND_VALUE - # set a value without permissive # for slave should have an index and good length # for master must append, not set - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if ismaster: + 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])") - api.option(path).value.set([first_value[0]]) - elif isslave: - api.option(path, 0).value.set(first_value[0]) - else: - api.option(path).value.set(first_value) - else: - if ismaster: + if not set_permissive: + api.option(path).value.set([first_value[0]]) + else: + api.forcepermissive.option(path).value.set([first_value[0]]) + elif not kwargs.get('propertyerror', False): raises(PropertiesOptionError, "api.option(path).value.set([first_value[0]])") - elif isslave: + if set_permissive: + api.forcepermissive.option(path).value.set([first_value[0]]) + else: + raises(PropertiesOptionError, "api.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])") + 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]) + else: + api.forcepermissive.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])") + if set_permissive: + api.forcepermissive.option(path, 0).value.set(first_value[0]) + else: + raises(PropertiesOptionError, "api.option(path, 0).value.set(first_value[0])") + raises(PropertiesOptionError, + "api.forcepermissive.option(path, 0).value.set(first_value[0])") + raises(APIError, + "api.unrestraint.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) + else: + api.forcepermissive.option(path).value.set(first_value) + elif not kwargs.get('propertyerror', False): + raises(PropertiesOptionError, "api.option(path).value.set(first_value)") + if set_permissive: + api.forcepermissive.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)") + + +@autocheck +def autocheck_set_value(api, path, **kwargs): + _autocheck_set_value(api, path, **kwargs) + + +@autocheck +def autocheck_get_value_permissive(api, path, **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) + if not multi: + first_value = FIRST_VALUE + elif submulti_ is False: + first_value = LIST_FIRST_VALUE + else: + first_value = SUBLIST_FIRST_VALUE # get value after set value without permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if isslave: + 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 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 - elif kwargs.get('permissive', False): - if isslave: + 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()") + + +def _autocheck_get_value(api, path, **kwargs): + multi = api.unrestraint.option(path).option.ismulti() + submulti_ = api.unrestraint.option(path).option.issubmulti() + isslave = api.unrestraint.option(path).option.isslave() + empty_value = _getdefault(api, path, multi, isslave, submulti_) + if not multi: + first_value = FIRST_VALUE + elif submulti_ is False: + first_value = LIST_FIRST_VALUE + 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() == empty_value 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() == empty_value - else: - if isslave: - raises(PropertiesOptionError, "api.option(path, 0).value.get()") - raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()") - else: - raises(PropertiesOptionError, "api.option(path).value.get()") - raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()") - - # set a value with permissive - if ismaster: - raises(APIError, "api.unrestraint.option(path).value.set(second_value[1])") - elif isslave: - raises(APIError, "api.unrestraint.option(path).value.set([first_value[0], second_value[1]])") - else: - raises(APIError, "api.unrestraint.option(path).value.set(second_value)") - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if ismaster: - raises(APIError, "api.forcepermissive.option(path, 1).value.set(second_value[1])") - api.forcepermissive.option(path).value.set([first_value[0], second_value[1]]) - elif isslave: - #FIXME - raises(PropertiesOptionError, "api.forcepermissive.option(path).value.set([first_value[0], second_value[1]])") - api.option(path, 1).value.set(second_value[1]) - raise Exception('ca entre ici') - else: - api.option(path).value.set(second_value) - elif kwargs.get('permissive', False): - if ismaster: - api.forcepermissive.option(path).value.set([first_value[0], second_value[1]]) - elif isslave: - api.forcepermissive.option(path, 1).value.set(second_value[1]) - else: - api.forcepermissive.option(path).value.set(first_value) - else: - if ismaster: - raises(PropertiesOptionError, "api.forcepermissive.option(path).value.set([first_value[0]])") - elif isslave: - raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.set(first_value[0])") - else: - raises(PropertiesOptionError, "api.forcepermissive.option(path).value.set(first_value)") - - # get value after set value with permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if isslave: - assert api.option(path, 0).value.get() == second_value[0] - assert api.option(path, 1).value.get() == second_value[1] - else: - assert api.option(path).value.get() == second_value - elif kwargs.get('permissive', False): - if ismaster: - raises(PropertiesOptionError, "api.option(path).value.get()") - assert api.forcepermissive.option(path).value.get() == second_value - elif isslave: - raises(PropertiesOptionError, "api.option(path, 0).value.get()") - raises(PropertiesOptionError, "api.option(path, 1).value.get()") - assert api.forcepermissive.option(path, 1).value.get() == second_value[1] - else: - raises(PropertiesOptionError, "api.option(path).value.get()") - assert api.forcepermissive.option(path).value.get() == first_value - else: - if isslave: - raises(PropertiesOptionError, "api.option(path, 0).value.get()") - raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()") else: raises(PropertiesOptionError, "api.option(path).value.get()") raises(PropertiesOptionError, "api.forcepermissive.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) + + @autocheck def autocheck_value_slave(api, path, **kwargs): - multi = api.unrestraint.option(path).option.ismulti() isslave = api.unrestraint.option(path).option.isslave() if not isslave: - #FIXME verifier pas de len ! + #FIXME raises(APIError, "api.option(path).value.len()") return if kwargs.get('propertyerror', False): + raises(PropertiesOptionError, "api.option(path).value.len()") + raises(PropertiesOptionError, "api.forcepermissive.option(path).value.len()") return + + multi = api.unrestraint.option(path).option.ismulti() submulti_ = api.forcepermissive.option(path).option.issubmulti() - if not kwargs.get('permissive', False): - length = api.option(path).value.len() - else: - length = api.forcepermissive.option(path).value.len() - assert length == 2 - value = [] - for idx in range(length): - value.append(api.forcepermissive.option(path, idx).value.get()) if not submulti_: second_value = LIST_SECOND_VALUE else: 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 + + value = [] + for idx in range(length): + value.append(api.forcepermissive.option(path, idx).value.get()) + assert value == [empty_value, second_value[1]] # cannot access to a slave with index too high if submulti_ is False: value = LIST_FIRST_VALUE[0] else: value = SUBLIST_FIRST_VALUE[0] + raises(IndexError, "api.forcepermissive.option(path, length).value.get()") raises(IndexError, "api.forcepermissive.option(path, length).value.set(value)") raises(IndexError, "api.forcepermissive.option(path, length).value.reset()") @@ -320,35 +431,43 @@ 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) # reset value without permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if not isslave: + if not isslave: + if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): api.option(path).value.reset() else: - api.option(path, 0).value.reset() - else: - if not isslave: raises(PropertiesOptionError, "api.option(path).value.reset()") + else: + if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): + api.option(path, 0).value.reset() else: raises(PropertiesOptionError, "api.option(path, 0).value.reset()") # get value after reset value without permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if isslave: + 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] - else: - assert api.option(path).value.get() == empty_value - elif kwargs.get('permissive', False): - if isslave: + 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: + 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 + +@autocheck +def autocheck_reset_value_permissive(api, path, **kwargs): + # check if is a multi, a master or a slave + isslave = api.unrestraint.option(path).option.isslave() + _autocheck_set_value(api, path, **kwargs) + # reset value with permissive if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): if not isslave: @@ -365,42 +484,56 @@ def autocheck_reset_value(api, path, **kwargs): raises(PropertiesOptionError, "api.forcepermissive.option(path).value.reset()") else: raises(PropertiesOptionError, "api.forcepermissive.option(path, 1).value.reset()") - - # get value after reset value with permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if isslave: - assert api.option(path, 0).value.get() == empty_value - assert api.option(path, 1).value.get() == empty_value - else: - assert api.option(path).value.get() == empty_value - elif kwargs.get('permissive', False): - if isslave: - raises(PropertiesOptionError, "api.option(path, 0).value.get()") - raises(PropertiesOptionError, "api.option(path, 1).value.get()") - assert api.forcepermissive.option(path, 0).value.get() == empty_value - assert api.forcepermissive.option(path, 1).value.get() == empty_value - else: - raises(PropertiesOptionError, "api.option(path).value.get()") - assert api.forcepermissive.option(path).value.get() == empty_value - - -@autocheck -def autocheck_value2(*args, **kwargs): - """re set value - """ - autocheck_value(*args, **kwargs) + _autocheck_default_value(api, path, **kwargs) @autocheck def autocheck_display(api, path, **kwargs): """re set value """ - #FIXME utile ? + #FIXME make_dict? + assert api.config + _autocheck_set_value(api, path, **kwargs) assert api.config -@autocheck -def autocheck_property(api, path, **kwargs): +def _getproperties(multi, isslave, kwargs): + # define properties + properties = copy(PROPERTIES_LIST) + if multi and not isslave: + default_props = ['empty'] + properties.append('empty') + else: + default_props = [] + extra_properties = kwargs.get('extra_properties') + if extra_properties: + properties.extend(extra_properties) + default_props.extend(extra_properties) + return default_props, tuple(properties) + + +def _check_default_properties(api, path, 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) + elif not kwargs.get('propertyerror', False): + raises(PropertiesOptionError, "api.option(path).property.get()") + assert set(api.forcepermissive.option(path).property.get()) == set(props) + else: + raises(PropertiesOptionError, "api.option(path).property.get()") + raises(PropertiesOptionError, "api.forcepermissive.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) + else: + raises(PropertiesOptionError, "api.option(path, 0).property.get()") + raises(APIError, "api.unrestraint.option(path, 0).property.get()") + + +def _autocheck_property(api, path, **kwargs): """get property from path """ # check if is a multi or a slave @@ -408,7 +541,7 @@ def autocheck_property(api, path, **kwargs): isslave = api.unrestraint.option(path).option.isslave() # define properties - properties = ['prop1', 'prop2'] + properties = copy(PROPERTIES_LIST) if multi and not isslave: default_props = ['empty'] properties.append('empty') @@ -418,139 +551,73 @@ def autocheck_property(api, path, **kwargs): if extra_properties: properties.extend(extra_properties) default_props.extend(extra_properties) - properties = tuple(properties) + default_props, properties = _getproperties(multi, isslave, kwargs) - # get properties without permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if not isslave: - assert set(api.option(path).property.get()) == set(default_props) - else: - assert set(api.option(path, 0).property.get()) == set(default_props) - assert set(api.option(path, 1).property.get()) == set(default_props) - else: - if not isslave: - raises(PropertiesOptionError, "api.option(path).property.get()") - else: - raises(PropertiesOptionError, "api.option(path, 0).property.get()") - - # get properties with permissive - if not isslave: - raises(APIError, "api.unrestraint.option(path).property.get()") - else: - raises(APIError, "api.unrestraint.option(path, 0).property.get()") - if not kwargs.get('propertyerror', False): - if not isslave: - assert set(api.forcepermissive.option(path).property.get()) == set(default_props) - else: - assert set(api.forcepermissive.option(path, 0).property.get()) == set(default_props) - assert set(api.forcepermissive.option(path, 1).property.get()) == set(default_props) - else: - if not isslave: - raises(PropertiesOptionError, "api.forcepermissive.option(path).property.get()") - else: - raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).property.get()") + _check_default_properties(api, path, 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) else: - if not isslave: - raises(PropertiesOptionError, "api.option(path).property.set(properties)") - else: - raises(PropertiesOptionError, "api.option(path, 0).property.set(properties)") + raises(PropertiesOptionError, "api.option(path).property.set(properties)") - # check properties after set without permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - assert set(api.option(path).property.get()) == set(properties) - assert set(api.forcepermissive.option(path).property.get()) == set(properties) - elif kwargs.get('permissive', False): - if not isslave: - raises(PropertiesOptionError, "api.option(path).property.get()") - assert set(api.forcepermissive.option(path).property.get()) == set(default_props) - else: - raises(PropertiesOptionError, "api.option(path, 0).property.get()") - assert set(api.forcepermissive.option(path, 0).property.get()) == set(default_props) - assert set(api.forcepermissive.option(path, 1).property.get()) == set(default_props) + _check_default_properties(api, path, kwargs, properties, default_props) + + +@autocheck +def autocheck_property(api, path, **kwargs): + _autocheck_property(api, path, **kwargs) + + +def _property_permissive(api, path, **kwargs): + # check if is a multi or a slave + multi = api.unrestraint.option(path).option.ismulti() + isslave = api.unrestraint.option(path).option.isslave() + + # define properties + properties = copy(PROPERTIES_LIST) + if multi and not isslave: + default_props = ['empty'] + properties.append('empty') else: - if not isslave: - raises(PropertiesOptionError, "api.option(path).property.get()") - raises(PropertiesOptionError, "api.forcepermissive.option(path).property.get()") - else: - raises(PropertiesOptionError, "api.option(path, 0).property.get()") - raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).property.get()") + default_props = [] + extra_properties = kwargs.get('extra_properties') + if extra_properties: + properties.extend(extra_properties) + default_props.extend(extra_properties) + default_props, properties = _getproperties(multi, isslave, kwargs) + + _check_default_properties(api, path, kwargs, default_props, default_props) # set properties with permissive - if not kwargs.get('propertyerror', False): + 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) + elif not kwargs.get('propertyerror', False): + raises(PropertiesOptionError, "api.option(path).property.set(properties)") api.forcepermissive.option(path).property.set(properties) else: + raises(PropertiesOptionError, "api.option(path).property.set(properties)") raises(PropertiesOptionError, "api.forcepermissive.option(path).property.set(properties)") - # check properties after set with permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if not isslave: - assert set(api.option(path).property.get()) == set(properties) - assert set(api.forcepermissive.option(path).property.get()) == set(properties) - else: - assert set(api.option(path, 0).property.get()) == set(properties) - assert set(api.forcepermissive.option(path, 0).property.get()) == set(properties) - assert set(api.option(path, 1).property.get()) == set(properties) - assert set(api.forcepermissive.option(path, 1).property.get()) == set(properties) - elif kwargs.get('permissive', False): - if not isslave: - raises(PropertiesOptionError, "api.option(path).property.get()") - assert set(api.forcepermissive.option(path).property.get()) == set(properties) - else: - raises(PropertiesOptionError, "api.option(path, 0).property.get()") - assert set(api.forcepermissive.option(path, 0).property.get()) == set(properties) - raises(PropertiesOptionError, "api.option(path, 1).property.get()") - assert set(api.forcepermissive.option(path, 1).property.get()) == set(properties) - else: - if not isslave: - raises(PropertiesOptionError, "api.option(path).property.get()") - raises(PropertiesOptionError, "api.forcepermissive.option(path).property.get()") - else: - raises(PropertiesOptionError, "api.option(path, 0).property.get()") - raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).property.get()") + _check_default_properties(api, path, kwargs, properties, properties) + + +@autocheck +def autocheck_property_permissive(api, path, **kwargs): + _property_permissive(api, path, **kwargs) @autocheck def autocheck_reset_property(api, path, **kwargs): """check properties after set with permissive """ - # check if is a multi or a slave - if not kwargs.get('propertyerror', False): - multi = api.forcepermissive.option(path).option.ismulti() - isslave = api.forcepermissive.option(path).option.isslave() - else: - raises(PropertiesOptionError, "api.forcepermissive.option(path).option.ismulti()") - raises(PropertiesOptionError, "api.forcepermissive.option(path).option.isslave()") - multi = api.unrestraint.option(path).option.ismulti() - isslave = api.unrestraint.option(path).option.isslave() + multi = api.unrestraint.option(path).option.ismulti() + isslave = api.unrestraint.option(path).option.isslave() + default_props, properties = _getproperties(multi, isslave, kwargs) - # define properties - properties = ['prop1', 'prop2'] - if multi and not isslave: - default_props = ['empty'] - properties.append('empty') - else: - default_props = [] - extra_properties = kwargs.get('extra_properties') - if extra_properties: - properties.extend(extra_properties) - default_props.extend(extra_properties) - properties = tuple(properties) - - # check properties - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - assert set(api.option(path).property.get()) == set(properties) - assert set(api.forcepermissive.option(path).property.get()) == set(properties) - elif kwargs.get('permissive', False): - if not isslave: - assert set(api.forcepermissive.option(path).property.get()) == set(properties) - else: - assert set(api.forcepermissive.option(path, 0).property.get()) == set(properties) - assert set(api.forcepermissive.option(path, 1).property.get()) == set(properties) + _property_permissive(api, path, **kwargs) # reset properties without permissive if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): @@ -558,22 +625,17 @@ def autocheck_reset_property(api, path, **kwargs): else: raises(PropertiesOptionError, "api.option(path).property.reset()") - # check properties - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if not isslave: - assert set(api.option(path).property.get()) == set(default_props) - assert set(api.forcepermissive.option(path).property.get()) == set(default_props) - else: - assert set(api.option(path, 0).property.get()) == set(default_props) - assert set(api.forcepermissive.option(path, 0).property.get()) == set(default_props) - assert set(api.option(path, 1).property.get()) == set(default_props) - assert set(api.forcepermissive.option(path, 1).property.get()) == set(default_props) - elif kwargs.get('permissive', False): - if not isslave: - assert set(api.forcepermissive.option(path).property.get()) == set(properties) - else: - assert set(api.forcepermissive.option(path, 0).property.get()) == set(properties) - assert set(api.forcepermissive.option(path, 1).property.get()) == set(properties) + _check_default_properties(api, path, kwargs, default_props, properties) + + +@autocheck +def autocheck_reset_property_permissive(api, path, **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) # reset properties with permissive raises(APIError, "api.unrestraint.option(path).property.set(properties)") @@ -584,69 +646,56 @@ def autocheck_reset_property(api, path, **kwargs): elif kwargs.get('permissive', False): api.forcepermissive.option(path).property.reset() - # check properties - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if not isslave: - assert set(api.option(path).property.get()) == set(default_props) - assert set(api.forcepermissive.option(path).property.get()) == set(default_props) - else: - assert set(api.option(path, 0).property.get()) == set(default_props) - assert set(api.forcepermissive.option(path, 0).property.get()) == set(default_props) - assert set(api.option(path, 1).property.get()) == set(default_props) - assert set(api.forcepermissive.option(path, 1).property.get()) == set(default_props) - elif kwargs.get('permissive', False): - if not isslave: - assert set(api.forcepermissive.option(path).property.get()) == set(default_props) - else: - assert set(api.forcepermissive.option(path, 0).property.get()) == set(default_props) - assert set(api.forcepermissive.option(path, 1).property.get()) == set(default_props) + _check_default_properties(api, path, kwargs, default_props, default_props) @autocheck -def autocheck_property2(*args, **kwargs): - return autocheck_property(*args, display=False, **kwargs) +def autocheck_context_owner(api, path, **kwargs): + owner = api.owner.get() + assert owner == OWNER + + +def _check_owner(api, path, 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 + elif not kwargs.get('propertyerror', False): + raises(PropertiesOptionError, "api.option(path).owner.get()") + assert api.forcepermissive.option(path).owner.get() == permissive_owner + else: + raises(PropertiesOptionError, "api.option(path).owner.get()") + raises(PropertiesOptionError, "api.forcepermissive.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' + assert api.option(path, 1).owner.get() == owner + assert api.forcepermissive.option(path, 0).owner.get() == 'default' + assert api.forcepermissive.option(path, 1).owner.get() == owner + elif not kwargs.get('propertyerror', False): + raises(PropertiesOptionError, "api.option(path, 0).owner.get()") + raises(PropertiesOptionError, "api.option(path, 1).owner.get()") + assert api.forcepermissive.option(path, 0).owner.get() == 'default' + assert api.forcepermissive.option(path, 1).owner.get() == permissive_owner + else: + raises(PropertiesOptionError, "api.option(path, 0).owner.get()") + raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.get()") @autocheck def autocheck_owner_with_value(api, path, **kwargs): """value is now changed, check owner in this case """ + _autocheck_set_value(api, path, **kwargs) + _check_owner(api, path, kwargs, OWNER, OWNER) + + +@autocheck +def autocheck_default_owner_with_value(api, path, **kwargs): + _autocheck_set_value(api, path, **kwargs) # check if is a isslave - if not kwargs.get('propertyerror', False): - isslave = api.forcepermissive.option(path).option.isslave() - else: - raises(PropertiesOptionError, "api.forcepermissive.option(path).option.isslave()") - isslave = api.unrestraint.option(path).option.isslave() - - owner = api.owner.get() - assert owner == OWNER - - # get owner without permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if not isslave: - assert api.option(path).owner.get() == owner - else: - assert api.option(path, 0).owner.get() == owner - assert api.option(path, 1).owner.get() == owner - else: - if not isslave: - raises(PropertiesOptionError, "api.option(path).owner.get()") - else: - raises(PropertiesOptionError, "api.option(path, 0).owner.get()") - raises(PropertiesOptionError, "api.option(path, 1).owner.get()") - - # get owner with permissive - if not kwargs.get('propertyerror', False): - if not isslave: - assert api.forcepermissive.option(path).owner.get() == owner - else: - assert api.forcepermissive.option(path, 0).owner.get() == 'default' - assert api.forcepermissive.option(path, 1).owner.get() == owner - else: - if not isslave: - raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.get()") - else: - raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.get()") + isslave = api.unrestraint.option(path).option.isslave() # test if is default owner without permissive if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): @@ -654,6 +703,14 @@ def autocheck_owner_with_value(api, path, **kwargs): else: raises(PropertiesOptionError, "api.option(path).owner.isdefault()") + +@autocheck +def autocheck_default_owner_with_value_permissive(api, path, **kwargs): + # check if is a isslave + isslave = api.unrestraint.option(path).option.isslave() + + _autocheck_set_value(api, path, **kwargs) + # test if is default owner with permissive if not kwargs.get('propertyerror', False): if not isslave: @@ -665,41 +722,43 @@ def autocheck_owner_with_value(api, path, **kwargs): raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.isdefault()") +@autocheck +def autocheck_set_owner_no_value(api, path, **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')") + else: + raises(ConfigError, "api.forcepermissive.option(path, 1).owner.set('new_user')") + + @autocheck def autocheck_set_owner(api, path, **kwargs): # test set owner without permissive - if not kwargs.get('propertyerror', False): - isslave = api.forcepermissive.option(path).option.isslave() - else: - raises(PropertiesOptionError, "api.forcepermissive.option(path).option.isslave()") - isslave = False + isslave = api.unrestraint.option(path).option.isslave() + + _autocheck_set_value(api, path, **kwargs) # set owner without permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if not isslave: + if not isslave: + if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): api.option(path).owner.set('new_user') else: - api.option(path, 1).owner.set('new_user') - else: - if not isslave: raises(PropertiesOptionError, "api.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 set without permissive - if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False): - if not isslave: - assert api.option(path).owner.get() == 'new_user' - assert api.forcepermissive.option(path).owner.get() == 'new_user' - else: - assert api.option(path, 1).owner.get() == 'new_user' - assert api.forcepermissive.option(path, 1).owner.get() == 'new_user' - elif not kwargs.get('propertyerror', False): - owner = api.owner.get() - if not isslave: - assert api.forcepermissive.option(path).owner.get() == owner - else: - assert api.forcepermissive.option(path, 1).owner.get() == owner + _check_owner(api, path, kwargs, 'new_user', OWNER) + + +@autocheck +def autocheck_set_owner_permissive(api, path, **kwargs): + isslave = api.unrestraint.option(path).option.isslave() + + _autocheck_set_value(api, path, **kwargs) # set owner with permissive if not kwargs.get('propertyerror', False): @@ -709,17 +768,13 @@ def autocheck_set_owner(api, path, **kwargs): api.forcepermissive.option(path, 1).owner.set('new_user1') else: if not isslave: - raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.set('new_user1')") + raises(PropertiesOptionError, + "api.forcepermissive.option(path).owner.set('new_user1')") else: - raises(PropertiesOptionError, "api.forcepermissive.option(path, 1).owner.set('new_user1')") + raises(PropertiesOptionError, + "api.forcepermissive.option(path, 1).owner.set('new_user1')") - # get owner set with permissive - if not kwargs.get('propertyerror', False): - if not isslave: - assert api.forcepermissive.option(path).owner.get() == 'new_user1' - else: - assert api.forcepermissive.option(path, 0).owner.get() == 'default' - assert api.forcepermissive.option(path, 1).owner.get() == 'new_user1' + _check_owner(api, path, kwargs, 'new_user1', 'new_user1') @autocheck @@ -756,93 +811,61 @@ def autocheck_option(api, path, **kwargs): def autocheck_permissive(api, path, **kwargs): """test permissive for hidden and disabled value """ - # check if is a multi, a master or a slave - if not kwargs.get('propertyerror', False): - multi = api.forcepermissive.option(path).option.ismulti() - submulti_ = api.forcepermissive.option(path).option.issubmulti() - ismaster = api.forcepermissive.option(path).option.ismaster() - isslave = api.forcepermissive.option(path).option.isslave() - else: - raises(PropertiesOptionError, "api.forcepermissive.option(path).option.ismulti()") - multi = api.unrestraint.option(path).option.ismulti() - submulti_ = api.unrestraint.option(path).option.issubmulti() - ismaster = api.unrestraint.option(path).option.ismaster() - isslave = api.unrestraint.option(path).option.isslave() - - # set default value (different if value is multi or not) - if not multi: - first_value = FIRST_VALUE - second_value = SECOND_VALUE - elif submulti_ is False: - first_value = LIST_FIRST_VALUE - second_value = LIST_SECOND_VALUE - else: - first_value = SUBLIST_FIRST_VALUE - second_value = SUBLIST_SECOND_VALUE - if multi and not isslave: - empty_value = LIST_EMPTY_VALUE - elif submulti_ and isslave: - empty_value = SUBLIST_EMPTY_VALUE - else: - empty_value = EMPTY_VALUE + # no permissive before + assert api.unrestraint.option(path).permissive.get() == frozenset() + if kwargs.get('permissive_od', False): + assert api.unrestraint.option(path.rsplit('.', 1)[0]).permissive.get() == frozenset() # cannot access to hidden value without forcepermissive # and to disabled value (with forcepermissive too) - if kwargs.get('propertyerror', False): - if not isslave: - raises(PropertiesOptionError, "api.option(path).value.get()") - raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()") - else: - raises(PropertiesOptionError, "api.option(path, 0).value.get()") - raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()") - elif kwargs.get('permissive', False): - if not isslave: - raises(PropertiesOptionError, "api.option(path).value.get()") - api.forcepermissive.option(path).value.get() - else: - raises(PropertiesOptionError, "api.option(path, 0).value.get()") - api.forcepermissive.option(path, 0).value.get() - else: - if not isslave: - api.option(path).value.get() - else: - api.option(path, 0).value.get() - assert api.unrestraint.option(path).permissive.get() == frozenset() - api.unrestraint.option(path).permissive.set(('disabled',)) + _autocheck_default_value(api, path, **kwargs) + + # set permissive + api.unrestraint.option(path).permissive.set(frozenset(['disabled'])) + + # have permissive assert api.unrestraint.option(path).permissive.get() == frozenset(['disabled']) - # can access to disabled value - if kwargs.get('permissive', False): - if not isslave: - raises(PropertiesOptionError, "api.option(path).value.get()") - api.forcepermissive.option(path).value.get() - else: - raises(PropertiesOptionError, "api.option(path, 0).value.get()") - api.forcepermissive.option(path, 0).value.get() - else: - if not isslave: - api.option(path).value.get() - else: - api.option(path, 0).value.get() + ckwargs = copy(kwargs) + ckwargs['propertyerror'] = False + _autocheck_default_value(api, path, **ckwargs) - #FIXME - #api.option(path).permissive.set(('disabled', 'hidden')) + api.unrestraint.option(path).permissive.set(frozenset(['disabled', 'hidden'])) - ## can access to value - #if not isslave: - # api.option(path).value.get() - #else: - # api.option(path, 0).value.get() - #assert api.option(path).permissive.get() == frozenset(['disabled', 'hidden']) - # - #print('FIXME del !!!') + # 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) + + if ckwargs.get('permissive_od', False): + # set permissive to OptionDescription + api.unrestraint.option(path.rsplit('.', 1)[0]).permissive.set(frozenset(['disabled', + 'hidden'])) + ckwargs['permissive'] = False + _autocheck_default_value(api, path, **ckwargs) + + # only hidden + api.unrestraint.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'])) + ckwargs = copy(kwargs) + ckwargs['permissive'] = False + _autocheck_default_value(api, path, **ckwargs) + + # no permissive + api.unrestraint.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) -def check_all(api, path, meta, multi, default, default_multi, **kwargs): +def check_all(cfg, path, meta, multi, default, default_multi, **kwargs): if DISPLAY: - text = u' {} launch tests for {}'.format(ICON, path, multi, default) + text = u' {} launch tests for {}'.format(ICON, path) if multi is True: text += u' as a multi' elif multi is submulti: @@ -855,7 +878,12 @@ def check_all(api, path, meta, multi, default, default_multi, **kwargs): text += u' with default multi' 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) for func in autocheck_registers: + api = getapi(cfg.duplicate()) if DISPLAY: print(u' {} {}'.format(ICON, func.__name__)) try: @@ -879,7 +907,7 @@ def check_deref(weakrefs): assert wrf() is None -def make_api(options, meta, multi, default, default_multi): +def make_conf(options, meta, multi, default, default_multi): weakrefs = [] def make_option(path, option_infos): #FIXME @@ -970,9 +998,7 @@ def make_api(options, meta, multi, default, default_multi): if meta: cfg = MetaConfig([cfg], session_id='metatest') weakrefs.append(weakref.ref(cfg)) - api = getapi(cfg) - weakrefs.append(weakref.ref(api)) - return api, weakrefs + return cfg, weakrefs DICT_PATHS = [ @@ -994,7 +1020,7 @@ DICT_PATHS = [ ('subod.second', {'second': {'disabled': True}}), ('subod.subsubod.third', {'third': {'hidden': True}})]), #test a config with masterslaves - OrderedDict([('odmaster.first', {'odmaster': {'master': True}}), + 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 @@ -1047,10 +1073,14 @@ def test_options(paths): kwargs['permissive'] = True if not od: kwargs.setdefault('extra_properties', []).append('hidden') + else: + kwargs['permissive_od'] = True if options.get('disabled', False) is True: kwargs['propertyerror'] = True if not od: kwargs.setdefault('extra_properties', []).append('disabled') + else: + kwargs['propertyerror_od'] = True def get_kwargs(path): kwargs = {} @@ -1067,18 +1097,18 @@ def test_options(paths): for multi in (False, True, submulti): if multi is False and default_multi: continue - api, weakrefs = make_api(paths, meta, multi, default, default_multi) - if api is None: + cfg, weakrefs = make_conf(paths, meta, multi, default, default_multi) + if cfg is None: continue if len(lpaths) == 9: - check_all(api, lpaths[3], meta, multi, default, default_multi, **get_kwargs(lpaths[0])) - check_all(api, lpaths[4], meta, multi, default, default_multi, **get_kwargs(lpaths[1])) - check_all(api, lpaths[5], meta, multi, default, default_multi, **get_kwargs(lpaths[2])) - check_all(api, lpaths[6], meta, multi, default, default_multi, **get_kwargs(lpaths[0])) - check_all(api, lpaths[7], meta, multi, default, default_multi, **get_kwargs(lpaths[1])) - check_all(api, lpaths[8], meta, multi, default, default_multi, **get_kwargs(lpaths[2])) + check_all(cfg, lpaths[3], meta, multi, default, default_multi, **get_kwargs(lpaths[0])) + check_all(cfg, lpaths[4], meta, multi, default, default_multi, **get_kwargs(lpaths[1])) + check_all(cfg, lpaths[5], meta, multi, default, default_multi, **get_kwargs(lpaths[2])) + check_all(cfg, lpaths[6], meta, multi, default, default_multi, **get_kwargs(lpaths[0])) + check_all(cfg, lpaths[7], meta, multi, default, default_multi, **get_kwargs(lpaths[1])) + check_all(cfg, lpaths[8], meta, multi, default, default_multi, **get_kwargs(lpaths[2])) else: for lpath in lpaths: - check_all(api, lpath, meta, multi, default, default_multi, **get_kwargs(lpath)) - del api + check_all(cfg, lpath, meta, multi, default, default_multi, **get_kwargs(lpath)) + del cfg check_deref(weakrefs)