"""test API """ #import weakref import pytest #import warnings #from copy import copy #from py.test import raises #from collections import OrderedDict #from .autopath import do_autopath #do_autopath() #from tiramisu import Config, MetaConfig, \ # StrOption, SymLinkOption, OptionDescription, Leadership, DynOptionDescription, \ # submulti, undefined, owners, Params, ParamOption, Calculation from tiramisu import Config, DynOptionDescription, OptionDescription, Leadership, \ StrOption, IntOption, ChoiceOption, SymLinkOption, \ Calculation, Params, ParamValue, ParamOption, ParamSelfOption, ParamInformation, ParamSelfInformation, ParamIndex, ParamSuffix, \ submulti, calc_value, owners from tiramisu.i18n import _ from tiramisu.option.baseoption import BaseOption from tiramisu.error import ConfigError, ConstError, PropertiesOptionError, LeadershipError from tiramisu.setting import ALLOWED_LEADER_PROPERTIES def return_var(val=None): return val def return_var_disabled(multi, p=None): if p is not None: multi = p if multi: return [] return None def return_val(multi): if multi: return ['val'] return 'val' def return_property(): return 'prop' def return_disabled(var=None): return 'disabled' def return_validator(self, other): return self == other def build_variables(*, mandatory=False, multi=False, leadership=False, dynoptiondescription=False, parent_variables=[], dynamic=False, hidden=False, ): base_name = 'str_' if mandatory: properties = ['mandatory'] base_name += 'mandatory_' else: properties = [] if multi is True: base_name += 'multi_' elif multi is submulti: base_name += 'submulti_' if leadership: param_multi = multi is submulti else: param_multi = multi if not param_multi: str1_5_informations = {'info': 'value'} cfg_informations = Calculation(return_var, Params(ParamInformation('cfg_key'))) else: str1_5_informations = {'info': ['value']} cfg_informations = [Calculation(return_var, Params(ParamInformation('cfg_key')))] if leadership: base_name += 'deps_follower_0_' if dynamic or dynoptiondescription: base_name += 'dynamic_' if hidden: base_name += 'hidden_' str1 = StrOption(base_name + 'information_deps', '', multi=multi, properties=tuple(properties), informations=str1_5_informations, ) str2 = StrOption(base_name + 'disabled_deps', '', multi=multi, properties=tuple(properties + ['disabled']), ) str3_name = base_name + 'calc_property_param_disabled' if not leadership: str3_name += '_deps' str3 = StrOption(str3_name, '', multi=multi, properties=tuple(properties + [Calculation(return_disabled, Params(ParamOption(str2, notraisepropertyerror=True)))]), ) choice = ChoiceOption(base_name + 'choice_deps', '', values=('val1', 'val2'), multi=multi, properties=tuple(properties), ) variables = [str1, str2, StrOption(base_name + 'calc_default', '', Calculation(return_val, Params(ParamValue(param_multi))), multi=multi, properties=tuple(properties), ), StrOption(base_name + 'calc_default_param', '', Calculation(return_var, Params(ParamOption(str1))), multi=multi, properties=tuple(properties) ), StrOption(base_name + 'calc_default_param_disable', '', Calculation(return_var_disabled, Params((ParamOption(str2, notraisepropertyerror=True), ParamValue(param_multi)))), multi=multi, properties=tuple(properties), ), StrOption(base_name + 'calc_property', '', multi=multi, properties=tuple(properties + [Calculation(return_property)]), ), StrOption(base_name + 'calc_property_disabled', '', multi=multi, properties=tuple(properties + [Calculation(return_disabled, Params(ParamOption(str1)))]), ), StrOption(base_name + 'calc_property_disabled_self', '', multi=multi, properties=tuple(properties + [Calculation(return_disabled, Params(ParamSelfOption()))]), ), StrOption(base_name + 'validator', '', multi=multi, properties=tuple(properties), validators=[Calculation(return_validator, Params((ParamSelfOption(), ParamOption(str1))))], ), StrOption(base_name + 'calc_default_information', '', Calculation(return_var, Params(ParamInformation('info', option=str1))), multi=multi, properties=tuple(properties), ), StrOption(base_name + 'calc_default_information_cfg', '', cfg_informations, multi=multi, properties=tuple(properties), ), str3, StrOption(base_name + 'calc_default_information_self', '', Calculation(return_var, Params(ParamSelfInformation('info'))), multi=multi, properties=tuple(properties), informations=str1_5_informations, ), choice, ] if not leadership: sym1 = SymLinkOption(base_name + 'symlink_information_deps', str1) sym2 = SymLinkOption(base_name + 'symlink_disabled_deps', str2) variables.extend([sym1, sym2, SymLinkOption(base_name + 'symlink_calc_property_disabled_deps', str3), SymLinkOption(base_name + 'symlink_choice_deps', choice), StrOption(base_name + 'calc_default_param_sym', '', Calculation(return_var, Params(ParamOption(sym1))), multi=multi, properties=tuple(properties) ), StrOption(base_name + 'calc_default_param_disable_sym', '', Calculation(return_var_disabled, Params((ParamOption(sym2, notraisepropertyerror=True), ParamValue(param_multi)))), multi=multi, properties=tuple(properties), ), StrOption(base_name + 'calc_property_param_disabled_sym', '', multi=multi, properties=tuple(properties + [Calculation(return_disabled, Params(ParamOption(sym2, notraisepropertyerror=True)))]), ) ]) else: default = Calculation(calc_value, Params(ParamIndex())) if param_multi: default = [default] variables.append(IntOption(base_name + 'calc_default_index', '', default, multi=multi, properties=tuple(properties), ) ) if dynoptiondescription: default = Calculation(calc_value, Params(ParamSuffix())) if param_multi: default = [default] variables.append(StrOption(base_name + 'calc_default_suffix', '', default, multi=multi, properties=tuple(properties), ) ) if not leadership: for idx, parent in enumerate(parent_variables): if not parent: continue base_name_2 = 'parent_' if dynamic or dynoptiondescription: base_name_2 += 'dynamic_' if hidden: base_name_2 += 'hidden_' base_name_3 = base_name_2 if mandatory: base_name_2 += 'mandatory_' variables.extend([ StrOption(f'{base_name_2}calc_default_param_{idx}', '', Calculation(return_var, Params(ParamOption(parent[0]))), properties=tuple(properties), ), StrOption(f'{base_name_2}calc_property_disabled_{idx}', '', properties=tuple(properties + [Calculation(return_disabled, Params(ParamOption(parent[0])))]), ), StrOption(f'{base_name_2}validator_{idx}', '', properties=tuple(properties), validators=[Calculation(return_validator, Params((ParamSelfOption(), ParamOption(parent[0]))))], ), StrOption(f'{base_name_2}calc_default_information_{idx}', '', Calculation(return_var, Params(ParamInformation('info', option=parent[0]))), properties=tuple(properties), ), SymLinkOption(f'{base_name_3}symlink_information_deps_{idx}', parent[0]), # StrOption(f'{base_name_2}calc_property_param_disabled_{idx}', '', properties=tuple(properties + [Calculation(return_disabled, Params(ParamOption(parent[1], notraisepropertyerror=True)))]), ), StrOption(f'{base_name_2}calc_default_param_disable_{idx}', '', Calculation(return_var_disabled, Params((ParamOption(parent[1], notraisepropertyerror=True), ParamValue(False)))), properties=tuple(properties), ), SymLinkOption(f'{base_name_3}symlink_disabled_deps_{idx}', parent[1]), ]) return variables def build_options_for_parent(dynoptiondescription, hidden, ): base_name = 'parent_' if dynoptiondescription: base_name += 'dynamic_' if hidden: base_name += 'hidden_' return (StrOption(base_name + 'information_deps', '', informations={'info': 'parent_value'}), StrOption(base_name + 'disabled_deps', '', properties=('disabled',), ), ) def build_root_variables(*, tree, **kwargs, ): parent_variables = [] dynamic = False hidden = False hidden_idx = 0 for t in tree: if hidden: hidden_idx += 1 if t.startswith('h'): t = t[1:] hidden = True if t == 'dod': dynamic=True parent_variables.append(build_options_for_parent(dynamic, hidden)) variables = build_variables(**kwargs, parent_variables=parent_variables, dynamic=dynamic, hidden=hidden) follower_params = kwargs.copy() follower_params['leadership'] = True if 'multi' in follower_params and follower_params['multi']: follower_params['multi'] = submulti else: follower_params['multi'] = True suffix = '' if dynamic: suffix += '_dynamic' lsuffix = suffix if hidden: lsuffix += '_hidden' variables.append(Leadership('leadership' + lsuffix, '', [StrOption('leader_multi_deps' + lsuffix, '', default=['l1', 'l2'], multi=True, ), ] + build_variables(**follower_params, parent_variables=parent_variables, dynamic=dynamic, hidden=hidden), )) suffixes = StrOption('suffixes_multi_deps' + lsuffix, '', ['d1', 'd2'], multi=True) variables.append(suffixes) dynamic_name = 'dynamic_' if hidden: dynamic_name += 'hidden_' variables.append(DynOptionDescription(dynamic_name, '', build_variables(**kwargs, dynoptiondescription=True, parent_variables=parent_variables, dynamic=dynamic, hidden=hidden), Calculation(return_var, Params(ParamOption(suffixes))))) tree.reverse() for idx, t in enumerate(tree): lsuffix = suffix variables.extend(parent_variables.pop(-1)) if hidden and idx <= hidden_idx: lsuffix = '_hidden' + suffix if t.startswith('h'): t = t[1:] properties = frozenset(['hidden']) else: properties = frozenset() if t == 'dod': variables = [DynOptionDescription('tree_dynamic' + lsuffix, '', variables, Calculation(return_var, Params(ParamValue(['var1', 'var2']))), properties=properties)] else: variables = [OptionDescription('tree' + lsuffix, '', variables, properties=properties)] od = OptionDescription('root', 'root', variables, informations={'cfg_key': 'cfg_info'}) return od PARAMS = [{}, {'mandatory': True}, {'multi': True}, {'mandatory': True, 'multi': True}, ] OD = [ [], ['od'], ['od', 'od'], ['hod'], ['hod', 'od'], ['od', 'hod'], ['dod'], ['hdod'], ['dod', 'dod'], ['hdod', 'dod'], ['dod', 'hdod'], ['dod', 'od'], ['dod', 'od', 'dod'], ['dod', 'od', 'dod', 'od'], ['dod', 'od', 'dod', 'hod'], ['dod', 'od', 'hdod', 'od'], ] SCENARII = [] for od in OD: SCENARII.append({'tree': od}) for params in PARAMS: SCENARII[-1].update(params) @pytest.fixture(scope="function", params=SCENARII) def root_variables(request): try: owners.addowner('test') except ConstError: pass ALLOWED_LEADER_PROPERTIES.add('new') return build_root_variables(**request.param) from pprint import pprint as pprint2 #pprint = pprint2 def pprint(a): print() def p(b): ret = {} for i, j in b.items(): k = i.name() if isinstance(j, dict): ret[k] = p(j) else: ret[k] = j return ret c = p(a) pprint2(c) def walk(cfg, idx=0): yield cfg for opt in cfg.list(): # print(' ' * idx, opt.path()) if opt.isoptiondescription(): yield from walk(opt, idx + 2) else: yield(opt) def _test_option(option, without_index=False): # optiondescription and option name = option.name() opt = option.get() if opt is None: # it's a 'root' object assert name is None assert option.isoptiondescription() assert not option.isleadership() assert not option.isdynamic() assert option.doc() is 'root' assert option.description() == 'root' assert option.path() is None assert not option.has_dependency() else: assert isinstance(name, str) assert isinstance(opt, BaseOption) assert (isinstance(opt, OptionDescription) and option.isoptiondescription()) or (not isinstance(opt, OptionDescription) and not option.isoptiondescription()) if option.isoptiondescription(): assert ('leadership' not in name and not option.isleadership()) or ('leadership' in name and option.isleadership()) if option.isleadership(): assert 'leader_' in option.leader().name() else: with pytest.raises(ConfigError): option.leader() else: with pytest.raises(ConfigError): option.leadership() assert option.isdynamic() == ('dynamic' in name) if option.isdynamic(): suffixes = [] for path in option.path().split('.'): if 'dynamicvar1' in path: suffixes.append('var1') if 'dynamicvar2' in path: suffixes.append('var2') if 'd1' in path: suffixes.append('d1') if 'd2' in path: suffixes.append('d2') assert option.suffixes() == suffixes assert isinstance(option.doc(), str) and option.doc() == name assert isinstance(option.description(), str) and option.description() == '' assert isinstance(option.path(), str) and (option.path() == name or option.path().endswith(f'.{name}')) if '_deps' in name: assert option.has_dependency(False) assert option.dependencies() else: assert not option.has_dependency(False) assert not option.dependencies() if option.isoptiondescription(): assert option.type() == 'optiondescription' elif 'index' in name: assert option.type() == _('integer') elif 'choice' in name: assert option.type() == _('choice') else: assert option.type() == _('string') # only option if option.isoptiondescription(): with pytest.raises(ConfigError): option.ismulti() with pytest.raises(ConfigError): option.issubmulti() with pytest.raises(ConfigError): option.isleader() with pytest.raises(ConfigError): option.isfollower() with pytest.raises(ConfigError): option.issymlinkoption() with pytest.raises(ConfigError): option.default() with pytest.raises(ConfigError): option.defaultmulti() with pytest.raises(ConfigError): option.pattern() with pytest.raises(ConfigError): option.index() else: assert 'symlink' in name and option.issymlinkoption() or 'symlink' not in name and not option.issymlinkoption() try: assert 'multi' in name and option.ismulti() or 'multi' not in name and not option.ismulti() except Exception as err: print(err) print(option.value.get()) raise Exception('err') assert 'submulti' in name and option.issubmulti() or 'submulti' not in name and not option.issubmulti() if option.issymlinkoption(): assert not option.isleader() assert not option.isfollower() with pytest.raises(ConfigError): option.pattern() assert option.index() is None else: assert 'leader' in name and option.isleader() or 'leader' not in name and not option.isleader() assert 'follower' in name and option.isfollower() or 'follower' not in name and not option.isfollower() if option.isfollower() and not without_index: assert option.index() in [0, 1] else: assert option.index() is None if option.type() == _('integer'): assert option.pattern() == '^[0-9]+$' else: assert not option.pattern() default = option.default() if 'calc_default' in name: assert isinstance(default, Calculation) or (isinstance(default, list) and len(default) == 1 and isinstance(default[0], Calculation)) elif 'suffixes_multi' in name: assert default == ['d1', 'd2'] elif 'leader_multi' in name: assert default == ['l1', 'l2'] elif 'multi' in name: assert default == [] else: assert default is None if option.issubmulti(): assert option.defaultmulti() == [] elif option.ismulti(): assert option.defaultmulti() is None def _test_information(cfg, option, without_index=False): name = option.name() # list lst = option.information.list() if name is None: assert lst == {'cfg_key', 'doc'} elif 'information' in name and ('information_self' in name or 'calc_default' not in name): assert lst == {'doc', 'info'} else: assert lst == {'doc'} # get assert option.information.get('unknown', 'no_value') == 'no_value' if name is None: assert option.information.get('doc') == 'root' else: assert option.information.get('doc') == '' if 'cfg_key' in lst: assert option.information.get('cfg_key') == 'cfg_info' if 'info' in lst: if 'parent' in name: value = 'parent_value' else: value = 'value' if 'multi' in name: value = [value] assert option.information.get('info') == value # set if not option.isoptiondescription() and option.issymlinkoption(): with pytest.raises(ConfigError): option.information.set('new', 'value') with pytest.raises(ConfigError): option.information.reset('new') return if not option.isoptiondescription() and option.isfollower() and not without_index: # index is not allowed with pytest.raises(ConfigError): option.information.set('new', 'value') with pytest.raises(ConfigError): option.information.reset('new') option.information.get('doc') with pytest.raises(ConfigError): option.information.set('new', 'value') option.information.list() with pytest.raises(ConfigError): option.information.remove('new') else: option.information.set('new', 'value') assert option.information.get('new') == 'value' assert option.information.list() == lst | {'new'} option.information.set('new', 'value2') assert option.information.get('new') == 'value2' assert option.information.list() == lst | {'new'} # remove option.information.remove('new') assert option.information.list() == lst with pytest.raises(ValueError): option.information.remove('doc') # Value def _test_value(cfg, option, unrestraint=False, without_index=False): #owner name = option.name() if option.isoptiondescription(): _test_owner_optiondescription(name, option) _test_value_optiondescription(name, option, unrestraint) elif not unrestraint and 'disabled' in name: if not without_index or 'calc_property' not in name or 'hidden' in name: _test_owner_disabled(name, option, without_index) _test_value_disabled(name, option, without_index) else: _test_owner_without_index(option) _test_value_without_index(option) elif not unrestraint and 'hidden' in name: _test_owner_disabled(name, option, without_index) _test_value_disabled(name, option, without_index) elif without_index: _test_owner_without_index(option) _test_value_without_index(option) else: _test_owner(option, without_index) _test_value_normal(name, cfg, option, unrestraint, without_index) def _test_owner_optiondescription(name, option): with pytest.raises((AttributeError, ConfigError)): option.owner.isdefault() if name is None: assert option.owner.get() == owners.user option.owner.set(owners.test) assert option.owner.get() == owners.test option.owner.set(owners.user) assert option.owner.get() == owners.user else: with pytest.raises(ConfigError): option.owner.get() with pytest.raises(ConfigError): option.owner.set(owners.test) def _test_value_optiondescription(name, option, unrestraint): if not unrestraint and name and 'hidden' in name: with pytest.raises(PropertiesOptionError): option.value.get() else: assert isinstance(option.value.get(), dict) if name != None: with pytest.raises(ConfigError): option.value.set('value') with pytest.raises(ConfigError): option.value.reset() with pytest.raises(ConfigError): option.value.default() with pytest.raises(ConfigError): option.value.valid() with pytest.raises(ConfigError): option.value.list() with pytest.raises(ConfigError): option.value.pop(1) with pytest.raises(ConfigError): option.value.len() def _test_owner_disabled(name, option, without_index): if without_index: errtype = ConfigError else: errtype = PropertiesOptionError with pytest.raises(errtype): option.owner.isdefault() with pytest.raises(errtype): option.owner.get() if 'symlink' in name: with pytest.raises(ConfigError): option.owner.set(owners.test) else: with pytest.raises(errtype): option.owner.set(owners.test) def _test_owner_without_index(option): with pytest.raises(ConfigError): option.owner.isdefault() with pytest.raises(ConfigError): option.owner.get() with pytest.raises(ConfigError): option.owner.set(owners.test) def _test_owner(option, without_index): if without_index: with pytest.raises(ConfigError): assert option.owner.isdefault() with pytest.raises(ConfigError): assert option.owner.get() else: assert option.owner.isdefault() assert option.owner.get() == owners.default with pytest.raises(ConfigError): # not availlable for symlink or without index or option has default value option.owner.set(owners.test) def _test_value_disabled(name, option, without_index): if without_index: errtype = ConfigError else: errtype = PropertiesOptionError with pytest.raises(errtype): option.value.get() if 'symlink' in name: with pytest.raises(ConfigError): option.value.set('val') with pytest.raises(ConfigError): option.value.reset() with pytest.raises(ConfigError): option.value.valid() else: with pytest.raises(errtype): option.value.set('val') with pytest.raises(errtype): option.value.reset() with pytest.raises(errtype): option.value.valid() #if without_index: # assert option.value.len() == 2 # if 'choice' in name: # assert option.value.list() == ('val1', 'val2') # else: # with pytest.raises(ConfigError): # option.value.list() #else: if 'leader' in name or 'follower' in name: with pytest.raises(PropertiesOptionError): option.value.len() else: with pytest.raises(ConfigError): option.value.len() if 'choice' in name and 'symlink' not in name: with pytest.raises(errtype): option.value.list() else: with pytest.raises(ConfigError): option.value.list() def _test_value_without_index(option): with pytest.raises(ConfigError): option.value.get() with pytest.raises(ConfigError): option.value.set('val') with pytest.raises(ConfigError): option.value.reset() with pytest.raises(ConfigError): option.value.valid() with pytest.raises(ConfigError): option.value.list() assert option.value.len() == 2 def _get_value(name, option, unrestraint): if 'calc_default_information' in name: if 'calc_default_information_cfg' in name: value = 'cfg_info' elif 'parent' in name: value = 'parent_value' else: value = 'value' if 'multi' in name: value = [value] elif 'calc_default_suffix' in name: value = option.suffixes()[-1] if 'multi' in name: value = [value] elif 'calc_default_index' in name: value = option.index() if 'multi' in name: value = [value] elif 'calc_default' in name and 'calc_default_param' not in name: value = 'val' if 'multi' in name: value = [value] elif 'suffixes_multi' in name: value = ['d1', 'd2'] elif 'leader_multi_deps' in name: value = ['l1', 'l2'] elif 'multi' in name: value = [] else: value = None return value def _test_value_normal(name, cfg, option, unrestraint, without_index): #value value = _get_value(name, option, unrestraint) if without_index: with pytest.raises(ConfigError): option.value.get() else: assert option.value.get() == value #set if option.issymlinkoption() or without_index: with pytest.raises(ConfigError): option.value.set(owners.test) with pytest.raises(ConfigError): option.value.reset() with pytest.raises(ConfigError): option.value.valid() if without_index: assert option.value.len() == 2 if 'choice' in name: assert option.value.list() == ('val1', 'val2') else: with pytest.raises(ConfigError): option.value.list() else: with pytest.raises(ConfigError): option.value.len() with pytest.raises(ConfigError): option.value.list() else: if option.type() == _('string'): new_value = 'new_value' new_value2 = 'new_value1' new_value3 = 'new_value2' elif option.type() == _('integer'): new_value = 10 new_value2 = 11 new_value3 = 12 elif 'choice' in name: new_value = 'val2' new_value2 = 'val1' if 'multi' in name: new_value = [new_value, new_value2] option.value.set(new_value) assert option.value.get() == new_value assert not option.owner.isdefault() assert option.owner.get() == owners.user # option.owner.set(owners.test) assert option.owner.get() == owners.test option.value.set(new_value) assert option.owner.get() == owners.user cfg.owner.set(owners.test) option.value.set(new_value) assert option.owner.get() == owners.test cfg.owner.set(owners.user) # if 'leader' in name: option.value.set(new_value + [new_value3]) assert option.value.len() == 3 with pytest.raises(LeadershipError): option.value.set(new_value) assert option.value.len() == 3 option.value.pop(2) assert option.value.get() == new_value # assert option.value.default() == value # option.value.reset() assert option.value.get() == value assert option.owner.isdefault() assert option.owner.get() == owners.default # valid assert option.value.valid() is True # list if 'choice' in name: assert option.value.list() == ['val1', 'val2'] else: with pytest.raises(ConfigError): option.value.list() if 'leader' in name or 'follower' in name: assert option.value.len() == 2 else: with pytest.raises(ConfigError): option.value.len() def _test_property(cfg, option, unrestraint=False, without_index=False): name = option.name() properties = [] properties_only_raises = [] properties_apply_requires = [] properties_uncalculated = [] if not option.isoptiondescription() and option.issymlinkoption(): name = option.option().name() if name is None: if unrestraint: properties.append('cache') properties_apply_requires.append('cache') properties_uncalculated.append('cache') else: properties.extend(['disabled', 'frozen', 'validator', 'cache', 'force_store_value', 'hidden']) properties_apply_requires.extend(['disabled', 'frozen', 'validator', 'cache', 'force_store_value', 'hidden']) properties_uncalculated.extend(['disabled', 'frozen', 'validator', 'cache', 'force_store_value', 'hidden']) if name and 'disabled' in name: properties.append('disabled') if not unrestraint: properties_only_raises.append('disabled') if not 'calc_property' in name: properties_apply_requires.append('disabled') properties_uncalculated.append('disabled') else: properties_uncalculated.append('calculation') if name and ('hidden' in name or 'hidden' in option.name()): properties.append('hidden') if not unrestraint: properties_only_raises.append('hidden') properties_apply_requires.append('hidden') properties_uncalculated.append('hidden') if name and 'mandatory' in name: properties.append('mandatory') properties_apply_requires.append('mandatory') properties_uncalculated.append('mandatory') if name and 'submulti' in name: # it's a follower pass elif name and 'multi' in name and not option.isfollower(): properties.append('unique') properties.append('empty') properties_apply_requires.append('unique') properties_apply_requires.append('empty') properties_uncalculated.append('unique') properties_uncalculated.append('empty') if name and 'calc_property' in name and not 'calc_property_disabled' in name and not 'property_param_disabled' in name: properties.append('prop') properties_uncalculated.append('calculation') if not without_index: assert option.property.get() == set(properties) assert option.property.get(only_raises=True) == set(properties_only_raises) assert option.property.get(apply_requires=False) == set(properties_apply_requires) option_property = option.property.get(uncalculated=True) if "calculation" in properties_uncalculated: new_option_property = set() for p in option_property: if isinstance(p, Calculation): properties_uncalculated.remove('calculation') else: new_option_property.add(p) assert new_option_property == set(properties_uncalculated) else: assert option_property == set(properties_uncalculated) # if (name is not None or not unrestraint) and (option.isoptiondescription() or not option.issymlinkoption()): assert 'new' not in option.property.get() option.property.add('new') assert 'new' in option.property.get() option.property.remove('new') assert 'new' not in option.property.get() if properties: if option.path() is not None: for prop in properties: with pytest.raises(ConfigError): option.property.remove(prop) assert option.property.get() == set(properties) # option.property.add('new') option.property.reset() else: for prop in properties: option.property.remove(prop) assert option.property.get() == set() for prop in properties: option.property.add(prop) assert option.property.get() == set(properties) # option.property.reset() assert option.property.get() == set() for prop in properties: option.property.add(prop) with pytest.raises(ConfigError): option.property.remove('unknown') else: for prop in properties: with pytest.raises(ConfigError): option.property.remove(prop) with pytest.raises(ConfigError): option.property.add('unknown') with pytest.raises(ConfigError): option.property.reset() assert option.property.get() == set(properties) else: with pytest.raises(ConfigError): option.property.get() with pytest.raises(ConfigError): option.property.get(only_raises=True) with pytest.raises(ConfigError): option.property.get(apply_requires=False) with pytest.raises(ConfigError): option.property.get(uncalculated=True) #with pytest.raises(ConfigError): option.property.add('new') #with pytest.raises(ConfigError): option.property.remove('new') #with pytest.raises(ConfigError): option.property.reset() # def _test_permissive(cfg, option, unrestraint=False, without_index=False): name = option.name() if name is None: default_permissives = {'hidden'} else: default_permissives = set() assert option.permissive.get() == default_permissives if (name is not None or not unrestraint) and (option.isoptiondescription() or not option.issymlinkoption()): option.permissive.add('new') assert option.permissive.get() == default_permissives | {'new'} option.permissive.remove('new') assert option.permissive.get() == default_permissives # with pytest.raises(ConfigError): option.permissive.remove('unknown') # option.permissive.add('new') option.permissive.reset() assert option.permissive.get() == default_permissives # if name and not unrestraint: props = set() if 'disabled' in name: props.add('disabled') if 'hidden' in name: props.add('hidden') if props: for p in props: if not without_index: assert option.property.get(only_raises=True) == props option.permissive.add(p) assert option.property.get(only_raises=True) == props - set([p]) option.permissive.remove(p) assert option.property.get(only_raises=True) == props else: with pytest.raises(ConfigError): option.property.get(only_raises=True) # else: with pytest.raises(ConfigError): option.permissive.add('new') with pytest.raises(ConfigError): option.permissive.remove('new') with pytest.raises(ConfigError): option.permissive.reset() def test_auto_root(root_variables): cfg = Config(root_variables) cfg.property.read_write() for option in walk(cfg.unrestraint): # we are in unrestraint mode, set option with property _test_option(option) _test_information(cfg, option) _test_value(cfg, option, True) _test_property(cfg, option, True) _test_permissive(cfg, option, True) if not option.isoptiondescription() and option.isfollower(): follower_without_index_option = cfg.unrestraint.option(option.path()) _test_option(follower_without_index_option, without_index=True) _test_information(cfg, follower_without_index_option, without_index=True) _test_value(cfg, follower_without_index_option, True, without_index=True) _test_property(cfg, follower_without_index_option, True, without_index=True) _test_permissive(cfg, follower_without_index_option, True, without_index=True) if option.path() is None: continue elif option.isoptiondescription(): new_option = cfg.option(option.path()) else: new_option = cfg.option(option.path(), option.index()) _test_option(new_option) _test_information(cfg, new_option) _test_value(cfg, new_option) _test_property(cfg, new_option) _test_permissive(cfg, new_option) if not option.isoptiondescription() and option.isfollower(): follower_without_index_option = cfg.option(option.path()) _test_option(follower_without_index_option, without_index=True) _test_information(cfg, follower_without_index_option, without_index=True) _test_value(cfg, follower_without_index_option, without_index=True) _test_property(cfg, follower_without_index_option, without_index=True) _test_permissive(cfg, follower_without_index_option, without_index=True) ## ## ##def test_auto_root_ro(root_variables): ## cfg = Config(root_variables) ## cfg.information.set('cfg_key', 'cfg_info') ## cfg.property.read_only() ## mandatories = cfg.value.mandatory() ## if not mandatories: ## pprint(cfg.value.get()) # # #def test_auto_root_without_cache(root_variables): # cfg = Config(root_variables) # cfg.information.set('cfg_key', 'cfg_info') # cfg.property.read_write() # cfg.property.remove('cache') # pprint(cfg.value.get()) ## ## ##def test_auto_root_without_cache_ro(root_variables): ## cfg = Config(root_variables) ## cfg.information.set('cfg_key', 'cfg_info') ## cfg.property.read_only() ## cfg.property.remove('cache') ## mandatories = cfg.value.mandatory() ## if not mandatories: ## pprint(cfg.value.get()) #FIXME #class ParamDynOption() #leadership property, ... #tester leader ! #FIXME dependencies doit contenir _dependencies_information #Choice #Choice calculé