tiramisu/tests/auto/test_auto.py

"""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, ParamIdentifier, \
        submulti, calc_value, owners
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_'
    #str_mandatory_multi_hidden_information_deps
    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(ParamIdentifier()))
        if param_multi:
            default = [default]
        variables.append(StrOption(base_name + 'calc_default_identifier',
                                   '',
                                   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
    identifier = ''
    if dynamic:
        identifier += '_dynamic'
    lidentifier = identifier
    if hidden:
        lidentifier += '_hidden'
    variables.append(Leadership('leadership' + lidentifier, '', [StrOption('leader_multi_deps' + lidentifier,
                                                                      '',
                                                                      default=['l1', 'l2'],
                                                                      multi=True,
                                                                      ),
                                                            ] + build_variables(**follower_params, parent_variables=parent_variables, dynamic=dynamic, hidden=hidden),
                                ))
    identifiers = StrOption('identifiers_multi_deps' + lidentifier, '', ['d1', 'd2'], multi=True)
    variables.append(identifiers)
    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(identifiers)))))
    tree.reverse()
    for idx, t in enumerate(tree):
        lidentifier = identifier
        variables.extend(parent_variables.pop(-1))
        if hidden and idx <= hidden_idx:
            if t.startswith('h'):
                lidentifier = '_self_hidden' + identifier
            else:
                lidentifier = '_hidden' + identifier
        if t.startswith('h'):
            t = t[1:]
            properties = frozenset(['hidden'])
        else:
            properties = frozenset()
        if t == 'dod':
            variables = [DynOptionDescription('tree_dynamic' + lidentifier, '', variables, Calculation(return_var, Params(ParamValue(['var1', 'var2']))), properties=properties)]
        else:
            variables = [OptionDescription('tree' + lidentifier, '', 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.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():
            identifiers = []
            for path in option.path().split('.'):
                if 'dynamicvar1' in path:
                    identifiers.append('var1')
                if 'dynamicvar2' in path:
                    identifiers.append('var2')
                if 'd1' in path:
                    identifiers.append('d1')
                if 'd2' in path:
                    identifiers.append('d2')
            assert option.identifiers() == identifiers
        assert isinstance(option.description(), str) and option.description() == name and option.description(uncalculated=True) == ''
        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.value.default()
        with pytest.raises(ConfigError):
            option.value.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.value.default(uncalculated=True)
        if 'calc_default' in name:
            assert isinstance(default, Calculation) or (isinstance(default, list) and len(default) == 1 and isinstance(default[0], Calculation))
        elif 'identifiers_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.value.defaultmulti() == []
        elif option.ismulti():
            assert option.value.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_identifier' in name:
        value = option.identifiers()[-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 'identifiers_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')
        if 'self_hidden' in option.name():
            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é