tiramisu/tests/test_option_callback.py

from .autopath import do_autopath
do_autopath()
from .config import config_type, get_config

from py.test import raises
import warnings

from tiramisu import Config
from tiramisu.config import KernelConfig
from tiramisu.setting import groups, owners
from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
    StrOption, OptionDescription, SymLinkOption, IPOption, NetmaskOption, Leadership, \
    undefined, Calculation, Params, ParamOption, ParamValue, ParamContext, calc_value
from tiramisu.error import PropertiesOptionError, ConflictError, LeadershipError, ConfigError
from tiramisu.i18n import _
from tiramisu.storage import list_sessions


def teardown_function(function):
    assert list_sessions() == [], 'session list is not empty when leaving "{}"'.format(function.__name__)


def return_val():
    return 'val'


def return_concat(*args):
    return '.'.join(list(args))


def return_list(value=None):
    return ['val', 'val']


def return_list2(*args):
    l = []
    for arg in args:
        if isinstance(arg, list):
            l.extend(arg)
        else:
            l.append(arg)
    return l


def return_value(value=None):
    return value


def return_value2(*args, **kwargs):
    value = list(args)
    value.extend(kwargs.values())
    return value


def return_value3(value=None, index=None):
    if index is not None and isinstance(value, list):
        if len(value) > index:
            return value[index]
        return None
    return value


def return_index(val1, val2=None, index=None, self=None):
    if index is None:
        return [val1, val2]
    if index == 0:
        return val1
    if index == 1:
        return val2

def return_calc(i, j, k):
    return i + j + k


def is_config(config, **kwargs):
    if isinstance(config, KernelConfig):
        return 'yes'
    else:
        return 'no'


def ret_from_config(config):
    cfg = Config(config)
    return cfg.option('val1').value.get()


def return_raise(*arg):
    raise Exception('test')


def return_valueerror(*arg):
    raise ValueError('test')


def make_description_duplicates():
    gcoption = ChoiceOption('name', 'GC name', ('ref', 'framework'), 'ref')
    ## dummy 1
    gcdummy = BoolOption('dummy', 'dummy', default=False)
    objspaceoption = ChoiceOption('objspace', 'Object space',
                                  ('std', 'thunk'), 'std')
    booloption = BoolOption('bool', 'Test boolean option', default=True)
    intoption = IntOption('int', 'Test int option', default=0)
    floatoption = FloatOption('float', 'Test float option', default=2.3)
    stroption = StrOption('str', 'Test string option', default="abc")
    boolop = BoolOption('boolop', 'Test boolean option op', default=True)
    wantref_option = BoolOption('wantref', 'Test requires', default=False)
    wantframework_option = BoolOption('wantframework', 'Test requires',
                                      default=False)
    # dummy2 (same path)
    gcdummy2 = BoolOption('dummy', 'dummy2', default=True)
    # dummy3 (same name)
    gcdummy3 = BoolOption('dummy', 'dummy2', default=True)
    gcgroup = OptionDescription('gc', '', [gcoption, gcdummy, gcdummy2, floatoption])
    descr = OptionDescription('constraints', '', [gcgroup, booloption, objspaceoption,
                              wantref_option, stroption,
                              wantframework_option,
                              intoption, boolop, gcdummy3])
    return descr


def test_identical_paths():
    """If in the schema (the option description) there is something that
    have the same name, an exection is raised
    """
    with warnings.catch_warnings(record=True) as w:
        raises(ConflictError, "make_description_duplicates()")


def test_hidden_if_in2(config_type):
    intoption = IntOption('int', 'Test int option', default=0)
    hidden_property = Calculation(calc_value,
                                  Params(ParamValue('hidden'),
                                         kwargs={'condition': ParamOption(intoption),
                                                 'expected': ParamValue(1),
                                                 'default': ParamValue(None)}))
    stroption = StrOption('str', 'Test string option', default="abc", properties=(hidden_property,))
    descr = OptionDescription('constraints', '', [stroption, intoption])
    cfg_ori = Config(descr)
    cfg_ori.property.read_write()
    cfg = get_config(cfg_ori, config_type)
    assert not 'hidden' in cfg.option('str').property.get()
    cfg.option('int').value.set(1)
    raises(PropertiesOptionError, "cfg.option('str').value.get()")
    raises(PropertiesOptionError, "cfg.option('str').value.set('uvw')")
    if config_type == 'tiramisu-api':
        cfg.send()
    assert 'hidden' in cfg_ori.unrestraint.option('str').property.get()


def test_hidden_if_in_with_group(config_type):
    gcoption = ChoiceOption('name', 'GC name', ('ref', 'framework'), 'ref')
    gcdummy = BoolOption('dummy', 'dummy', default=False)

    floatoption = FloatOption('float', 'Test float option', default=2.3)

    objspaceoption = ChoiceOption('objspace', 'Object space',
                                  ('std', 'thunk'), 'std')
    booloption = BoolOption('bool', 'Test boolean option', default=True)
    intoption = IntOption('int', 'Test int option', default=0)
    stroption = StrOption('str', 'Test string option', default="abc")
    hidden_property = Calculation(calc_value,
                                  Params(ParamValue('hidden'),
                                         kwargs={'condition': ParamOption(intoption),
                                                 'expected': ParamValue(1),
                                                 'default': ParamValue(None)}))
    gcgroup = OptionDescription('gc', '', [gcoption, gcdummy, floatoption], properties=(hidden_property,))
    descr = OptionDescription('constraints', '', [gcgroup, booloption,
                              objspaceoption, stroption, intoption])
    cfg_ori = Config(descr)
    cfg_ori.property.read_write()
    cfg = get_config(cfg_ori, config_type)
    assert not 'hidden' in cfg_ori.option('str').property.get()
    cfg.option('int').value.set(1)
    if config_type == 'tiramisu-api':
        cfg.send()
    raises(PropertiesOptionError, "cfg_ori.option('gc.name').value.get()")


def test_disabled_with_group():
    gcoption = ChoiceOption('name', 'GC name', ('ref', 'framework'), 'ref')
    gcdummy = BoolOption('dummy', 'dummy', default=False)

    floatoption = FloatOption('float', 'Test float option', default=2.3)

    objspaceoption = ChoiceOption('objspace', 'Object space',
                                  ('std', 'thunk'), 'std')
    booloption = BoolOption('bool', 'Test boolean option', default=True)
    intoption = IntOption('int', 'Test int option', default=0)
    stroption = StrOption('str', 'Test string option', default="abc")
    disabled_property = Calculation(calc_value,
                                    Params(ParamValue('disabled'),
                                           kwargs={'condition': ParamOption(intoption),
                                                   'expected': ParamValue(1),
                                                   'default': ParamValue(None)}))
    gcgroup = OptionDescription('gc', '', [gcoption, gcdummy, floatoption], properties=(disabled_property,))
    descr = OptionDescription('constraints', '', [gcgroup, booloption,
                                                  objspaceoption, stroption, intoption])
    cfg = Config(descr)
    cfg.property.read_write()
    assert cfg.option('gc.name').value.get()
    cfg.option('int').value.set(1)
    raises(PropertiesOptionError, "cfg.option('gc.name').value.get()")
#____________________________________________________________


def make_description_callback():
    gcoption = ChoiceOption('name', 'GC name', ('ref', 'framework'), 'ref')
    gcdummy = BoolOption('dummy', 'dummy')
    objspaceoption = ChoiceOption('objspace', 'Object space',
                                  ('std', 'thunk'), 'std')
    booloption = BoolOption('bool', 'Test boolean option', default=True)
    intoption = IntOption('int', 'Test int option', default=0)
    floatoption = FloatOption('float', 'Test float option', default=2.3)
    stroption = StrOption('str', 'Test string option', default="abc")
    boolop = BoolOption('boolop', 'Test boolean option op', default=True)
    hidden_property = Calculation(calc_value,
                                  Params(ParamValue('hidden'),
                                         kwargs={'condition': ParamOption(boolop),
                                                 'expected': ParamValue(True),
                                                 'default': ParamValue(None)}))
    wantref_option = BoolOption('wantref', 'Test requires', default=False, properties=(hidden_property,))
    wantframework_option = BoolOption('wantframework', 'Test requires',
                                      default=False,
                                      properties=(hidden_property,))
    gcgroup = OptionDescription('gc', '', [gcoption, gcdummy, floatoption])
    descr = OptionDescription('constraints', '', [gcgroup, booloption, objspaceoption,
                              wantref_option, stroption,
                              wantframework_option,
                              intoption, boolop])
    return descr


def test_has_callback():
    descr = make_description_callback()
    # here the owner is 'default'
    cfg = Config(descr)
    cfg.property.read_write()
    cfg.option('bool').value.set(False)
    # because dummy has a callback
    cfg.property.add('freeze')
    cfg.option('gc.dummy').property.add('frozen')
    raises(PropertiesOptionError, "cfg.option('gc.dummy').value.set(True)")


def test_freeze_and_has_callback():
    descr = make_description_callback()
    cfg = Config(descr)
    cfg.property.read_write()
    cfg.option('bool').value.set(False)
    cfg.property.add('freeze')
    cfg.option('gc.dummy').property.add('frozen')
    raises(PropertiesOptionError, "cfg.option('gc.dummy').value.set(True)")


def test_callback(config_type):
    val1 = StrOption('val1', "", callback=return_val)
    val2 = StrOption('val2', "")
    maconfig = OptionDescription('rootconfig', '', [val1, val2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    if config_type != 'tiramisu-api':
        assert cfg.option('val1').option.callbacks() != (None, None)
        assert cfg.option('val2').option.callbacks() == (None, None)
    assert cfg.option('val1').value.get() == 'val'
    cfg.option('val1').value.set('new-val')
    assert cfg.option('val1').value.get() == 'new-val'
    cfg.option('val1').value.reset()
    assert cfg.option('val1').value.get() == 'val'


def test_callback_params_without_callback():
    raises(ValueError, "StrOption('val2', '', callback_params=Params(ParamValue('yes')))")


def test_params():
    raises(ValueError, "Params([ParamContext()])")
    raises(ValueError, "Params('str')")
    raises(ValueError, "Params(('str',))")
    raises(ValueError, "Params(kwargs=[ParamContext()])")
    raises(ValueError, "Params(kwargs={'a': 'str'})")


def test_param_option():
    val1 = StrOption('val1', "")
    raises(ValueError, "ParamOption('str')")
    raises(AssertionError, "ParamOption(val1, 'str')")


def test_callback_invalid():
    raises(AssertionError, 'val1 = StrOption("val1", "", callback="string")')
    raises(AssertionError, 'val1 = StrOption("val1", "", callback=return_val, callback_params="string")')
    val1 = StrOption('val1', "", 'val')
    val1
    raises(AssertionError, "StrOption('val2', '', callback=return_value, callback_params={'': 'string'})")
    raises(AssertionError, "StrOption('val4', '', callback=return_value, callback_params={'value': (('string', False),)})")
    raises(AssertionError, "StrOption('val4', '', callback=return_value, callback_params={'value': ((val1, 'string'),)})")
    raises(AssertionError, "StrOption('val4', '', callback=return_value, callback_params={'value': ((val1, False, 'unknown'),)})")
    raises(AssertionError, "StrOption('val4', '', callback=return_value, callback_params={'value': ((val1,),)})")


def test_callback_with_context():
    context = ParamContext()
    value = ParamValue('string')
    params = Params((context,), {'value': value})
    val1 = StrOption("val1", "", callback=is_config, callback_params=params)
    maconfig = OptionDescription('rootconfig', '', [val1])
    cfg = Config(maconfig)
    assert cfg.option('val1').value.get() == 'yes'


def test_callback_with_context_named():
    context = ParamContext()
    params = Params(kwargs={'config': context})
    val1 = StrOption("val1", "", callback=is_config, callback_params=params)
    maconfig = OptionDescription('rootconfig', '', [val1])
    cfg = Config(maconfig)
    assert cfg.option('val1').value.get() == 'yes'


def test_callback_with_error(config_type):
    val1 = StrOption("val1", "", callback=is_config, callback_params=Params(ParamValue('string'), kwargs={'value': ParamValue('string')}))
    maconfig = OptionDescription('rootconfig', '', [val1])
    cfg = Config(maconfig)
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1').value.get() == 'no'


def test_callback_with_context_value():
    context = ParamContext()
    params = Params((context,))
    val1 = StrOption("val1", "")
    val2 = StrOption("val2", "", callback=ret_from_config, callback_params=params)
    maconfig = OptionDescription('rootconfig', '', [val1, val2])
    cfg = Config(maconfig)
    cfg.option('val1').value.set('yes')
    assert cfg.option('val1').value.get() == 'yes'
    assert cfg.option('val2').value.get() == 'yes'
    cfg.option('val1').value.set('no')
    assert cfg.option('val1').value.get() == 'no'
    assert cfg.option('val2').value.get() == 'no'


def test_callback_value(config_type):
    val1 = StrOption('val1', "", 'val')
    val2 = StrOption('val2', "", callback=return_value, callback_params=Params(ParamOption(val1)))
    val3 = StrOption('val3', "", callback=return_value, callback_params=Params(ParamValue('yes')))
    val4 = StrOption('val4', "", callback=return_value, callback_params=Params(kwargs={'value': ParamOption(val1)}))
    val5 = StrOption('val5', "", callback=return_value, callback_params=Params(ParamValue('yes')))
    maconfig = OptionDescription('rootconfig', '', [val1, val2, val3, val4, val5])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1').value.get() == 'val'
    assert cfg.option('val2').value.get() == 'val'
    assert cfg.option('val4').value.get() == 'val'
    cfg.option('val1').value.set('new-val')
    assert cfg.option('val1').value.get() == 'new-val'
    assert cfg.option('val2').value.get() == 'new-val'
    assert cfg.option('val4').value.get() == 'new-val'
    cfg.option('val1').value.reset()
    assert cfg.option('val1').value.get() == 'val'
    assert cfg.option('val2').value.get() == 'val'
    assert cfg.option('val3').value.get() == 'yes'
    assert cfg.option('val4').value.get() == 'val'
    assert cfg.option('val5').value.get() == 'yes'


def test_callback_value_tuple(config_type):
    val1 = StrOption('val1', "", 'val1')
    val2 = StrOption('val2', "", 'val2')
    val3 = StrOption('val3', "", callback=return_concat, callback_params=Params((ParamOption(val1), ParamOption(val2))))
    val4 = StrOption('val4', "", callback=return_concat, callback_params=Params((ParamValue('yes'), ParamValue('no'))))
    maconfig = OptionDescription('rootconfig', '', [val1, val2, val3, val4])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1').value.get() == 'val1'
    assert cfg.option('val2').value.get() == 'val2'
    assert cfg.option('val3').value.get() == 'val1.val2'
    assert cfg.option('val4').value.get() == 'yes.no'
    cfg.option('val1').value.set('new-val')
    assert cfg.option('val3').value.get() == 'new-val.val2'
    cfg.option('val1').value.reset()
    assert cfg.option('val3').value.get() == 'val1.val2'


def test_callback_value_force_permissive2(config_type):
    val1 = StrOption('val1', "", 'val', properties=('disabled',))
    val2 = StrOption('val2', "", callback=return_value, callback_params=Params(ParamOption(val1)))
    val3 = StrOption('val3', "", callback=return_value, callback_params=Params(ParamOption(val1, True)))
    maconfig = OptionDescription('rootconfig', '', [val1, val2, val3])
    cfg = Config(maconfig)
    cfg.property.read_only()
    if config_type != 'tiramisu-api':
        raises(ConfigError, "cfg.option('val2').value.get()")
        cfg.option('val3').value.get() is None
    else:
        raises(ConfigError, "get_config(cfg, config_type)")


def test_callback_value_force_permissive_kwargs():
    val1 = StrOption('val1', "", 'val', properties=('disabled',))
    val2 = StrOption('val2', "", callback=return_value, callback_params=Params(value=ParamOption(val1)))
    val3 = StrOption('val3', "", callback=return_value, callback_params=Params(value=ParamOption(val1, True)))
    maconfig = OptionDescription('rootconfig', '', [val1, val2, val3])
    cfg = Config(maconfig)
    cfg.property.read_only()
    raises(ConfigError, "cfg.option('val2').value.get()")
    cfg.option('val3').value.get() is None


def test_callback_symlink(config_type):
    val1 = StrOption('val1', "", 'val')
    val2 = SymLinkOption('val2', val1)
    val3 = StrOption('val3', "", callback=return_value, callback_params=Params(ParamOption(val2)))
    maconfig = OptionDescription('rootconfig', '', [val1, val2, val3])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1').value.get() == 'val'
    assert cfg.option('val2').value.get() == 'val'
    assert cfg.option('val3').value.get() == 'val'
    cfg.option('val1').value.set('new-val')
    assert cfg.option('val1').value.get() == 'new-val'
    assert cfg.option('val3').value.get() == 'new-val'
    cfg.option('val1').value.reset()
    assert cfg.option('val1').value.get() == 'val'
    assert cfg.option('val3').value.get() == 'val'


def test_callback_list():
    val1 = StrOption('val1', "", callback=return_list)
    maconfig = OptionDescription('rootconfig', '', [val1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    raises(ValueError, "cfg.option('val1').value.get()")


def test_callback_list2():
    val1 = StrOption('val1', "", callback=return_list)
    #val2 = StrOption('val2', "", callback=return_value, callback_params=Params(ParamOption(val1)))
    val2 = StrOption('val2', "", callback=return_value, callback_params=Params(ParamOption(val1)))  # , 'forcepermissive': False}]})
    maconfig = OptionDescription('rootconfig', '', [val1, val2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    raises(ValueError, "cfg.option('val1').value.get()")
    #cfg.val2
    raises(ValueError, "cfg.option('val2').value.get()")


def test_callback_multi(config_type):
    val1 = StrOption('val1', "", callback=return_val, multi=True)
    maconfig = OptionDescription('rootconfig', '', [val1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1').value.get() == ['val']
    cfg.option('val1').value.set(['new-val'])
    assert cfg.option('val1').value.get() == ['new-val']
    cfg.option('val1').value.set(['new-val', 'new-val2'])
    assert cfg.option('val1').value.get() == ['new-val', 'new-val2']
    cfg.option('val1').value.reset()
    assert cfg.option('val1').value.get() == ['val']


def test_callback_multi_value(config_type):
    val1 = StrOption('val1', "", ['val'], multi=True)
    #val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)))
    #val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamValue('yes')))
    #val4 = StrOption('val4', "", multi=True, callback=return_list2, callback_params={'': ((val1, False), 'yes')})
    option = ParamOption(val1)
    params1 = Params((option,))
    value = ParamValue('yes')
    params2 = Params((value,))
    params3 = Params((option, value))
    val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params=params1)
    val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=params2)
    val4 = StrOption('val4', "", multi=True, callback=return_list2, callback_params=params3)
    maconfig = OptionDescription('rootconfig', '', [val1, val2, val3, val4])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1').value.get() == ['val']
    assert cfg.option('val2').value.get() == ['val']
    assert cfg.option('val4').value.get() == ['val', 'yes']
    cfg.option('val1').value.set(['new-val'])
    assert cfg.option('val1').value.get() == ['new-val']
    assert cfg.option('val2').value.get() == ['new-val']
    assert cfg.option('val4').value.get() == ['new-val', 'yes']
    cfg.option('val1').value.set(['new-val', 'new-val2'])
    assert cfg.option('val1').value.get() == ['new-val', 'new-val2']
    assert cfg.option('val2').value.get() == ['new-val', 'new-val2']
    assert cfg.option('val4').value.get() == ['new-val', 'new-val2', 'yes']
    cfg.option('val1').value.reset()
    assert cfg.option('val1').value.get() == ['val']
    assert cfg.option('val2').value.get() == ['val']
    assert cfg.option('val3').value.get() == ['yes']
    assert cfg.option('val4').value.get() == ['val', 'yes']
    cfg.option('val2').value.set(['val', 'new'])
    assert cfg.option('val1').value.get() == ['val']
    assert cfg.option('val2').value.get() == ['val', 'new']


def test_callback_multi_list(config_type):
    val1 = StrOption('val1', "", callback=return_list, multi=True)
    maconfig = OptionDescription('rootconfig', '', [val1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1').value.get() == ['val', 'val']
    cfg.option('val1').value.set(['new-val'])
    assert cfg.option('val1').value.get() == ['new-val']
    cfg.option('val1').value.set(['new-val', 'new-val2'])
    assert cfg.option('val1').value.get() == ['new-val', 'new-val2']
    cfg.option('val1').value.reset()
    assert cfg.option('val1').value.get() == ['val', 'val']


def test_callback_multi_list_extend(config_type):
    val1 = StrOption('val1', "", callback=return_list2, callback_params=Params((ParamValue(['1', '2', '3']), ParamValue(['4', '5']))), multi=True)
    maconfig = OptionDescription('rootconfig', '', [val1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1').value.get() == ['1', '2', '3', '4', '5']


def test_callback_multi_callback(config_type):
    val1 = StrOption('val1', "", multi=True, callback=return_val)
    interface1 = OptionDescription('val1', '', [val1])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1.val1').value.get() == ['val']
    cfg.option('val1.val1').value.set(['val1', undefined])
    assert cfg.option('val1.val1').value.get() == ['val1', 'val']


def test_callback_leader_and_followers_leader(config_type):
    val1 = StrOption('val1', "", multi=True, callback=return_val)
    val2 = StrOption('val2', "", multi=True)
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1.val1').value.get() == ['val']
    cfg.option('val1.val1').value.set([undefined, undefined])
    assert cfg.option('val1.val1').value.get() == ['val', 'val']
    assert cfg.option('val1.val2', 0).value.get() == None
    assert cfg.option('val1.val2', 1).value.get() == None


def test_callback_follower(config_type):
    val1 = StrOption('val1', "", multi=True)
    val2 = StrOption('val2', "", multi=True, callback=return_value3, callback_params=Params(ParamValue(['string', 'new'])))
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    cfg.option('val1.val1').value.set(['val'])
    assert cfg.option('val1.val2', 0).value.get() == 'string'
    cfg.option('val1.val1').value.set(['val', 'val1'])
    assert cfg.option('val1.val2', 0).value.get() == 'string'
    assert cfg.option('val1.val2', 1).value.get() == 'new'
    cfg.option('val1.val1').value.set(['val', 'val1', 'val2'])
    assert cfg.option('val1.val2', 0).value.get() == 'string'
    assert cfg.option('val1.val2', 1).value.get() == 'new'
    assert cfg.option('val1.val2', 2).value.get() == None
    cfg.option('val1.val1').value.set(['val', 'val1', 'val2', 'val3'])
    assert cfg.option('val1.val2', 0).value.get() == 'string'
    assert cfg.option('val1.val2', 1).value.get() == 'new'
    assert cfg.option('val1.val2', 2).value.get() == None
    assert cfg.option('val1.val2', 3).value.get() == None


def test_callback_leader_and_followers_leader2(config_type):
    val1 = StrOption('val1', "", multi=True)
    val2 = StrOption('val2', "", multi=True, default_multi='val2')
    val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val2)))
    val4 = StrOption('val4', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val3)))
    interface1 = Leadership('val1', '', [val1, val2, val3, val4])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    cfg.option('val1.val1').value.set(['val'])
    assert cfg.option('val1.val4', 0).value.get() == 'val2'
    assert cfg.option('val1.val3', 0).value.get() == 'val2'
    assert cfg.option('val1.val2', 0).value.get() == 'val2'


def test_callback_leader_and_followers_leader_mandatory1(config_type):
    val = StrOption('val', "", default='val')
    val1 = StrOption('val1', "", multi=True, callback=return_value2, callback_params=Params(ParamOption(val)), properties=('mandatory',))
    val3 = StrOption('val3', "", multi=True, callback=return_index, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
    val4 = StrOption('val4', "", multi=True, callback=return_index, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
    interface1 = Leadership('val1', '', [val1, val3, val4])
    maconfig = OptionDescription('rootconfig', '', [val, interface1])
    cfg_ori = Config(maconfig)
    cfg_ori.property.read_only()
    cfg = get_config(cfg_ori, config_type)
    assert cfg.option('val1.val3', 0).value.get() == 'val'
    assert cfg.option('val1.val4', 0).value.get() == 'val'
    assert cfg.option('val1.val1').value.get() == ['val']
    if config_type == 'tiramisu-api':
        cfg.send()
    cfg_ori.property.read_write()
    cfg = get_config(cfg_ori, config_type)
    cfg.option('val1.val1').value.set([undefined, 'val3'])
    if config_type == 'tiramisu-api':
        cfg.send()
    cfg_ori.property.read_only()
    cfg = get_config(cfg_ori, config_type)
    assert cfg.option('val1.val1').value.get() == ['val', 'val3']
    assert cfg.option('val1.val3', 0).value.get() == 'val'
    if config_type != 'tiramisu-api':
        # FIXME
        raises(PropertiesOptionError, "cfg.option('val1.val3', 1).value.get()")
        raises(PropertiesOptionError, "cfg.option('val1.val4', 1).value.get()")


def test_callback_leader_and_followers_leader_mandatory2(config_type):
    val = StrOption('val', "", default='val')
    val_ = StrOption('val_', "", default='val_')
    val1 = StrOption('val1', "", multi=True, callback=return_index, callback_params=Params(ParamOption(val), {'val2': ParamOption(val_)}), properties=('mandatory',))
    val3 = StrOption('val3', "", multi=True, callback=return_index, callback_params=Params(ParamOption(val1), {'val2': ParamOption(val_)}), properties=('mandatory',))
    val4 = StrOption('val4', "", multi=True, callback=return_index, callback_params=Params(ParamOption(val1), {'val2': ParamOption(val_)}), properties=('mandatory',))
    interface1 = Leadership('val1', '', [val1, val3, val4])
    maconfig = OptionDescription('rootconfig', '', [val, val_, interface1])
    cfg_ori = Config(maconfig)
    cfg_ori.property.read_only()
    cfg = get_config(cfg_ori, config_type)
    assert cfg.option('val1.val3', 0).value.get() == 'val'
    assert cfg.option('val1.val3', 1).value.get() == 'val_'
    assert cfg.option('val1.val4', 0).value.get() == 'val'
    assert cfg.option('val1.val4', 1).value.get() == 'val_'
    assert cfg.option('val1.val1').value.get() == ['val', 'val_']
    cfg_ori.property.read_write()
    cfg = get_config(cfg_ori, config_type)
    cfg.option('val1.val1').value.set(['val', 'val_', 'val3'])
    assert cfg.option('val1.val1').value.get() == ['val', 'val_', 'val3']
    cfg_ori.property.read_only()
    cfg = get_config(cfg_ori, config_type)
    assert cfg.option('val1.val3', 0).value.get() == 'val'
    assert cfg.option('val1.val3', 1).value.get() == 'val_'
    assert cfg.option('val1.val4', 0).value.get() == 'val'
    assert cfg.option('val1.val4', 1).value.get() == 'val_'
    if config_type != 'tiramisu-api':
        # FIXME
        raises(PropertiesOptionError, "cfg.option('val1.val3', 2).value.get()")
        raises(PropertiesOptionError, "cfg.option('val1.val4', 2).value.get()")
    assert cfg.option('val1.val1').value.get() == ['val', 'val_', 'val3']


def test_callback_leader_and_followers_leader_mandatory3(config_type):
    val = StrOption('val', "", default='val')
    val_ = StrOption('val_', "", default='val_')
    val1 = StrOption('val1', "", multi=True, callback=return_value2, callback_params=Params(ParamOption(val), {'val': ParamOption(val_)}), properties=('mandatory',))
    val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
    val4 = StrOption('val4', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
    interface1 = Leadership('val1', '', [val1, val3, val4])
    maconfig = OptionDescription('rootconfig', '', [val, val_, interface1])
    cfg_ori = Config(maconfig)
    cfg_ori.property.read_only()
    cfg = get_config(cfg_ori, config_type)
    assert cfg.option('val1.val3', 0).value.get() == 'val'
    assert cfg.option('val1.val3', 1).value.get() == 'val_'
    assert cfg.option('val1.val4', 0).value.get() == 'val'
    assert cfg.option('val1.val4', 1).value.get() == 'val_'
    assert cfg.option('val1.val1').value.get() == ['val', 'val_']
    cfg_ori.property.read_write()
    cfg = get_config(cfg_ori, config_type)
    cfg.option('val1.val1').value.set(['val', 'val_', 'val3'])
    cfg_ori.property.read_only()
    cfg = get_config(cfg_ori, config_type)
    assert cfg.option('val1.val3', 0).value.get() == 'val'
    assert cfg.option('val1.val3', 1).value.get() == 'val_'
    assert cfg.option('val1.val3', 2).value.get() == 'val3'
    assert cfg.option('val1.val4', 0).value.get() == 'val'
    assert cfg.option('val1.val4', 1).value.get() == 'val_'
    assert cfg.option('val1.val4', 2).value.get() == 'val3'
    assert cfg.option('val1.val1').value.get() == ['val', 'val_', 'val3']


def test_callback_leader_and_followers_leader_mandatory4(config_type):
    val = StrOption('val', "", default='val')
    val1 = StrOption('val1', "", multi=True, callback=return_value2, callback_params=Params(ParamOption(val)), properties=('mandatory',))
    val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
    val4 = StrOption('val4', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)), properties=('mandatory',))
    interface1 = Leadership('val1', '', [val1, val3, val4])
    maconfig = OptionDescription('rootconfig', '', [val, interface1])
    cfg_ori = Config(maconfig)
    cfg_ori.property.read_only()
    cfg = get_config(cfg_ori, config_type)
    #raises(IndexError, "cfg.option('val1.val3').value.get()")
    assert cfg.option('val1.val3', 0).value.get() == 'val'
    assert cfg.option('val1.val4', 0).value.get() == 'val'
    assert cfg.option('val1.val1').value.get() == ['val']
    cfg_ori.property.read_write()
    cfg = get_config(cfg_ori, config_type)
    cfg.option('val1.val1').value.set(['val', 'val3'])
    cfg_ori.property.read_only()
    cfg = get_config(cfg_ori, config_type)
    assert cfg.option('val1.val1').value.get() == ['val', 'val3']
    assert cfg.option('val1.val3', 0).value.get() == 'val'
    assert cfg.option('val1.val3', 1).value.get() == 'val3'
    assert cfg.option('val1.val4', 0).value.get() == 'val'
    assert cfg.option('val1.val4', 1).value.get() == 'val3'


def test_callback_leader_and_followers_leader3():
    val1 = StrOption('val1', "", multi=True, properties=('mandatory', 'empty'))
    val2 = StrOption('val2', "", multi=True, default_multi='val2', properties=('expert',))
    val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val2)))
    val4 = StrOption('val4', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val3)))
    interface1 = Leadership('val1', '', [val1, val2, val3, val4])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    # FIXME cfg = get_config(cfg, config_type)
    assert list(cfg.value.mandatory()) == ['val1.val1']


def test_callback_leader_and_followers_leader4():
    val1 = StrOption('val1', "", ['val1'], multi=True, properties=('mandatory',))
    val2 = StrOption('val2', "", multi=True, default_multi='val2', properties=('expert', 'mandatory'))
    val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val2)))
    val4 = StrOption('val4', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val3)))
    interface1 = Leadership('val1', '', [val1, val2, val3, val4])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    # FIXME cfg = get_config(cfg, config_type)
    cfg.property.add('expert')
    cfg.permissive.set(frozenset(['expert']))
    assert list(cfg.value.mandatory()) == []


def test_consistency_leader_and_followers_leader_mandatory_transitive():
    #default value
    val1 = IPOption('val1', "", ['192.168.0.1'], multi=True, properties=('mandatory',))
    val2 = NetmaskOption('val2', "", multi=True, default_multi='255.255.255.0', properties=('disabled', 'mandatory'))
    val2.impl_add_consistency('ip_netmask', val1)
    #no value
    val3 = IPOption('val3', "", multi=True, properties=('mandatory',))
    val4 = NetmaskOption('val4', "", multi=True, default_multi='255.255.255.0', properties=('disabled', 'mandatory'))
    val4.impl_add_consistency('ip_netmask', val3)
    interface1 = Leadership('val1', '', [val1, val2])
    interface2 = Leadership('val3', '', [val3, val4])
    maconfig = OptionDescription('rootconfig', '', [interface1, interface2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    # FIXME cfg = get_config(cfg, config_type)
    try:
        cfg.option('val1.val1').value.get()
    except PropertiesOptionError as error:
        assert str(error) == str(_('cannot access to {0} "{1}" because "{2}" has {3} {4}').format('option', 'val1', 'val2', _('property'), '"disabled"'))
    else:
        raise Exception('must raises')
    raises(PropertiesOptionError, "cfg.option('val3.val3').value.get()")
    assert list(cfg.value.mandatory()) == []


def test_consistency_leader_and_followers_leader_mandatory_non_transitive():
    #no value
    val1 = IPOption('val1', "", multi=True, properties=('mandatory',))
    val2 = NetmaskOption('val2', "", multi=True, default_multi='255.255.255.0', properties=('disabled', 'mandatory'))
    val2.impl_add_consistency('ip_netmask', val1, transitive=False)
    #default value
    val3 = IPOption('val3', "", ['192.168.0.1'], multi=True, properties=('mandatory',))
    val4 = NetmaskOption('val4', "", multi=True, default_multi='255.255.255.0', properties=('disabled', 'mandatory'))
    val4.impl_add_consistency('ip_netmask', val3, transitive=False)
    interface1 = Leadership('val1', '', [val1, val2])
    interface2 = Leadership('val3', '', [val3, val4])
    maconfig = OptionDescription('rootconfig', '', [interface1, interface2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    # FIXME cfg = get_config(cfg, config_type)
    assert list(cfg.value.mandatory()) == ["val1.val1"]


def test_callback_leader_and_followers_leader_list(config_type):
    val1 = StrOption('val1', "", multi=True, callback=return_list)
    val2 = StrOption('val2', "", multi=True)
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1.val1').value.get() == ['val', 'val']
    assert cfg.option('val1.val2', 0).value.get() == None
    assert cfg.option('val1.val2', 1).value.get() == None
    cfg.option('val1.val1').value.set(['val', 'val', undefined])
    assert cfg.option('val1.val1').value.get() == ['val', 'val', None]
    assert cfg.option('val1.val2', 0).value.get() == None
    assert cfg.option('val1.val2', 1).value.get() == None
    assert cfg.option('val1.val2', 2).value.get() == None
    cfg.option('val1.val1').value.reset()
    assert cfg.option('val1.val1').value.get() == ['val', 'val']
    assert cfg.option('val1.val2', 0).value.get() == None
    assert cfg.option('val1.val2', 1).value.get() == None
    cfg.option('val1.val1').value.pop(1)
    assert cfg.option('val1.val1').value.get() == ['val']
    assert cfg.option('val1.val2', 0).value.get() == None


def test_callback_leader_and_followers_leader_follower_list(config_type):
    val1 = StrOption('val1', "", multi=True)
    val2 = StrOption('val2', "", multi=True, callback=return_list)
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1.val1').value.get() == []
    if config_type == 'tiramisu-api':
        # when "tiramisu-api", raise when set and not in get function
        raises(ConfigError, "cfg.option('val1.val1').value.set(['val1'])")
    else:
        cfg.option('val1.val1').value.set(['val1'])
        raises(LeadershipError, "cfg.option('val1.val2', 0).value.get()")


def test_callback_leader_and_followers_follower(config_type):
    val1 = StrOption('val1', "", multi=True)
    val2 = StrOption('val2', "", multi=True, callback=return_val)
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1.val1').value.get() == []
    #
    cfg.option('val1.val1').value.set(['val1'])
    assert cfg.option('val1.val1').value.get() == ['val1']
    assert cfg.option('val1.val2', 0).value.get() == 'val'
    #
    cfg.option('val1.val1').value.set(['val1', 'val2'])
    assert cfg.option('val1.val1').value.get() == ['val1', 'val2']
    assert cfg.option('val1.val2', 0).value.get() == 'val'
    assert cfg.option('val1.val2', 1).value.get() == 'val'
    #
    cfg.option('val1.val1').value.set(['val1', 'val2', 'val3'])
    assert cfg.option('val1.val1').value.get() == ['val1', 'val2', 'val3']
    assert cfg.option('val1.val2', 0).value.get() == 'val'
    assert cfg.option('val1.val2', 1).value.get() == 'val'
    assert cfg.option('val1.val2', 2).value.get() == 'val'
    #
    cfg.option('val1.val1').value.pop(2)
    assert cfg.option('val1.val1').value.get() == ['val1', 'val2']
    assert cfg.option('val1.val2', 0).value.get() == 'val'
    assert cfg.option('val1.val2', 1).value.get() == 'val'
    #
    cfg.option('val1.val2', 0).value.set('val2')
    cfg.option('val1.val2', 1).value.set('val2')
    assert cfg.option('val1.val2', 0).value.get() == 'val2'
    assert cfg.option('val1.val2', 1).value.get() == 'val2'
    #
    cfg.option('val1.val1').value.set(['val1', 'val2', 'val3'])
    assert cfg.option('val1.val2', 0).value.get() == 'val2'
    assert cfg.option('val1.val2', 1).value.get() == 'val2'
    assert cfg.option('val1.val2', 2).value.get() == 'val'


def test_callback_leader_and_followers():
    val1 = StrOption('val1', "", multi=True)
    val2 = StrOption('val2', "", multi=True, callback=return_val)
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()


def test_callback_leader_and_followers_follower_cal(config_type):
    val3 = StrOption('val3', "", multi=True)
    val1 = StrOption('val1', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val3)))
    val2 = StrOption('val2', "", multi=True, callback=return_val)
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1, val3])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    #
    assert cfg.option('val3').value.get() == []
    assert cfg.option('val1.val1').value.get() == []
    #
    cfg.option('val1.val1').value.set(['val1'])
    cfg.option('val3').value.set(['val1'])
    assert cfg.option('val1.val1').value.get() == ['val1']
    assert cfg.option('val1.val2', 0).value.get() == 'val'
    #
    cfg.option('val1.val1').value.reset()
    cfg.option('val1.val2', 0).value.set('val')
    #
    cfg.option('val3').value.set(['val1', 'val2'])
    assert cfg.option('val1.val2', 0).value.get() == 'val'
    assert cfg.option('val1.val2', 1).value.get() == 'val'
    assert cfg.option('val1.val1').value.get() == ['val1', 'val2']
    # len of follower is higher than leader's one
    cfg.option('val1.val2', 0).value.set('val1')
    cfg.option('val1.val2', 1).value.set('val2')
    if config_type == 'tiramisu-api':
        # when "tiramisu-api", raise when set and not in get function
        raises(ConfigError, "cfg.option('val3').value.set(['val1'])")
    else:
        cfg.option('val3').value.set(['val1'])
        assert cfg.option('val1.val1').value.get() == ['val1']
        raises(LeadershipError, "cfg.option('val1.val2', 0).value.get()")
    #
    cfg.option('val3').value.set(['val1', 'val2', 'val3'])
    assert cfg.option('val1.val2', 0).value.get() == 'val1'
    assert cfg.option('val1.val2', 1).value.get() == 'val2'
    assert cfg.option('val1.val2', 2).value.get() == 'val'


def test_callback_leader_and_followers_leader_disabled():
    #properties must be transitive
    val1 = StrOption('val1', "", ['val1'], multi=True, properties=('disabled',))
    val2 = StrOption('val2', "", multi=True)
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    raises(PropertiesOptionError, "cfg.option('val1.val1').value.get()")
    raises(PropertiesOptionError, "cfg.option('val1.val1').value.set(['yes'])")
    raises(PropertiesOptionError, "cfg.option('val1.val2', 0).value.get()")


def test_callback_leader_and_followers_leader_callback_disabled():
    val0 = StrOption('val0', "", multi=True, properties=('disabled',))
    val1 = StrOption('val1', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val0)))
    val2 = StrOption('val2', "", multi=True)
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1, val0])
    cfg = Config(maconfig)
    cfg.property.read_write()
    raises(ConfigError, "cfg.option('val1.val1').value.get()")
    raises(ConfigError, "cfg.option('val1.val2').value.get()")
    cfg.property.pop('disabled')
    cfg.option('val1.val1').value.set([])
    cfg.property.add('disabled')
    assert cfg.option('val1.val1').value.get() == []


def test_callback_leader_and_followers_follower_disabled():
    val1 = StrOption('val1', "", multi=True)
    val2 = StrOption('val2', "", multi=True, properties=('disabled',))
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1])
    cfg = Config(maconfig)
    cfg.property.read_write()
    assert cfg.option('val1.val1').value.get() == []
    cfg.option('val1.val1').value.set(['yes'])
    assert cfg.option('val1.val1').value.get() == ['yes']
    cfg.property.pop('disabled')
    assert cfg.option('val1.val2', 0).value.get() == None
    cfg.option('val1.val2', 0).value.set('no')
    cfg.option('val1.val1').value.set(['yes', 'yes2', 'yes3'])
    cfg.option('val1.val2', 2).value.set('no1')
    assert cfg.option('val1.val2', 0).value.get() == 'no'
    assert cfg.option('val1.val2', 1).value.get() == None
    assert cfg.option('val1.val2', 2).value.get() == 'no1'
    cfg.property.add('disabled')
    cfg.option('val1.val1').value.pop(0)
    assert cfg.option('val1.val1').value.get() == ['yes2', 'yes3']
    cfg.property.pop('disabled')
    assert cfg.option('val1.val2', 0).value.get() == None
    assert cfg.option('val1.val2', 1).value.get() == 'no1'


def test_callback_leader_and_followers_follower_callback_disabled():
    val0 = StrOption('val0', "", multi=True, properties=('disabled',))
    val1 = StrOption('val1', "", multi=True)
    val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val0)))
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1, val0])
    cfg = Config(maconfig)
    cfg.property.read_write()
    assert cfg.option('val1.val1').value.get() == []
    cfg.option('val1.val1').value.set(['yes'])
    assert cfg.option('val1.val1').value.get() == ['yes']
    cfg.property.pop('disabled')
    cfg.option('val1.val2', 0).value.set('no')
    cfg.option('val1.val1').value.set(['yes', 'yes1'])
    assert cfg.option('val1.val2', 0).value.get() == 'no'
    cfg.property.add('disabled')
    cfg.option('val1.val1').value.pop(1)


def test_callback_leader_and_followers_value():
    val4 = StrOption('val4', '', multi=True, default=['val10', 'val11'])
    val1 = StrOption('val1', "", multi=True)
    val2 = StrOption('val2', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val1)))
    val3 = StrOption('val3', "", multi=True, callback=return_value, callback_params=Params(ParamValue('yes')))
    val5 = StrOption('val5', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val4)))
    val6 = StrOption('val6', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val5)))
    interface1 = Leadership('val1', '', [val1, val2, val3, val5, val6])
    maconfig = OptionDescription('rootconfig', '', [interface1, val4])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg.option('val4').value.get() == ['val10', 'val11']
    assert cfg.option('val1.val1').value.get() == []
    #raises(LeadershipError, "cfg.val1.val1")
    #raises(LeadershipError, "cfg.val1.val2")
    #raises(LeadershipError, "cfg.val1.val3")
    #raises(LeadershipError, "cfg.val1.val5")
    #raises(LeadershipError, "cfg.val1.val6")
    #
    #default calculation has greater length
    #raises(LeadershipError, "cfg.option('val1.val1').value.set(['val1']")
    #
    cfg.option('val1.val1').value.set(['val1', 'val2'])
    assert cfg.option('val1.val1').value.get() == ['val1', 'val2']
    assert cfg.option('val1.val2', 0).value.get() == 'val1'
    assert cfg.option('val1.val2', 1).value.get() == 'val2'
    assert cfg.option('val1.val3', 0).value.get() == 'yes'
    assert cfg.option('val1.val3', 1).value.get() == 'yes'
    raises(LeadershipError, "cfg.option('val1.val5', 0).value.get()")
    raises(LeadershipError, "cfg.option('val1.val5', 1).value.get()")
    raises(LeadershipError, "cfg.option('val1.val6', 0).value.get()")
    raises(LeadershipError, "cfg.option('val1.val6', 1).value.get()")
    #
    cfg.option('val1.val1').value.set(['val1', 'val2', 'val3'])
    assert cfg.option('val1.val1').value.get() == ['val1', 'val2', 'val3']
    assert cfg.option('val1.val2', 0).value.get() == 'val1'
    assert cfg.option('val1.val2', 1).value.get() == 'val2'
    assert cfg.option('val1.val2', 2).value.get() == 'val3'
    assert cfg.option('val1.val3', 0).value.get() == 'yes'
    assert cfg.option('val1.val3', 1).value.get() == 'yes'
    assert cfg.option('val1.val3', 2).value.get() == 'yes'
    raises(LeadershipError, "cfg.option('val1.val5', 2).value.get()")
    raises(LeadershipError, "cfg.option('val1.val6', 2).value.get()")
    #
    cfg.option('val1.val1').value.pop(2)
    assert cfg.option('val1.val1').value.get() == ['val1', 'val2']
    assert cfg.option('val1.val2', 0).value.get() == 'val1'
    assert cfg.option('val1.val2', 1).value.get() == 'val2'
    assert cfg.option('val1.val3', 0).value.get() == 'yes'
    assert cfg.option('val1.val3', 1).value.get() == 'yes'
    #
    cfg.option('val1.val2', 0).value.set('val2')
    cfg.option('val1.val2', 1).value.set('val2')
    cfg.option('val1.val3', 0).value.set('val2')
    cfg.option('val1.val3', 1).value.set('val2')
    cfg.option('val1.val5', 0).value.set('val2')
    cfg.option('val1.val5', 1).value.set('val2')
    assert cfg.option('val1.val2', 0).value.get() == 'val2'
    assert cfg.option('val1.val2', 1).value.get() == 'val2'
    assert cfg.option('val1.val3', 0).value.get() == 'val2'
    assert cfg.option('val1.val3', 1).value.get() == 'val2'
    assert cfg.option('val1.val5', 0).value.get() == 'val2'
    assert cfg.option('val1.val5', 1).value.get() == 'val2'
    assert cfg.option('val1.val6', 0).value.get() == 'val2'
    assert cfg.option('val1.val6', 1).value.get() == 'val2'
    #
    cfg.option('val1.val1').value.set(['val1', 'val2', 'val3'])
    assert cfg.option('val1.val2', 2).value.get() == 'val3'
    assert cfg.option('val1.val3', 2).value.get() == 'yes'


def test_callback_leader():
    val2 = StrOption('val2', "", multi=True, callback=return_value)
    val1 = StrOption('val1', "", multi=True, callback=return_value, callback_params=Params(ParamOption(val2)))
    raises(ValueError, "Leadership('val1', '', [val1, val2])")


def test_callback_different_type(config_type):
    val = IntOption('val', "", default=2)
    val_ = IntOption('val_', "", default=3)
    val1 = IntOption('val1', "", multi=True)
    val2 = IntOption('val2', "", multi=True, callback=return_calc, callback_params=Params((ParamOption(val), ParamOption(val1)), {'k': ParamOption(val_)}))
    interface1 = Leadership('val1', '', [val1, val2])
    maconfig = OptionDescription('rootconfig', '', [interface1, val, val_])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val1.val1').value.get() == []
    cfg.option('val1.val1').value.set([1])
    assert cfg.option('val1.val1').value.get() == [1]
    assert cfg.option('val1.val2', 0).value.get() == 6
    cfg.option('val1.val1').value.set([1, 3])
    assert cfg.option('val1.val1').value.get() == [1, 3]
    assert cfg.option('val1.val2', 0).value.get() == 6
    assert cfg.option('val1.val2', 1).value.get() == 8
    cfg.option('val1.val1').value.set([1, 3, 5])
    assert cfg.option('val1.val1').value.get() == [1, 3, 5]
    assert cfg.option('val1.val2', 0).value.get() == 6
    assert cfg.option('val1.val2', 1).value.get() == 8
    assert cfg.option('val1.val2', 2).value.get() == 10


def test_callback_hidden():
    opt1 = BoolOption('opt1', '')
    opt2 = BoolOption('opt2', '', callback=return_value, callback_params=Params(ParamOption(opt1)))
    od1 = OptionDescription('od1', '', [opt1], properties=('hidden',))
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    raises(PropertiesOptionError, "cfg.option('od1.opt1').value.get()")
    # do not raise, forcepermissive
    cfg.option('od2.opt2').value.get()


def test_callback_hidden_permissive():
    opt1 = BoolOption('opt1', '')
    opt2 = BoolOption('opt2', '', callback=return_value, callback_params=Params(ParamOption(opt1)))
    od1 = OptionDescription('od1', '', [opt1], properties=('hidden',))
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.permissive.set(frozenset(['hidden']))
    cfg.property.read_write()
    raises(PropertiesOptionError, "cfg.option('od1.opt1').value.get()")
    cfg.option('od2.opt2').value.get()


def test_callback_hidden_permissive_callback():
    opt1 = BoolOption('opt1', '')
    opt2 = BoolOption('opt2', '', callback=return_value, callback_params=Params(ParamOption(opt1, True)))
    od1 = OptionDescription('od1', '', [opt1], properties=('hidden',))
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    raises(PropertiesOptionError, "cfg.option('od1.opt1').value.get()")
    cfg.option('od2.opt2').value.get()


def test_callback_two_disabled():
    opt1 = BoolOption('opt1', '', properties=('disabled',))
    opt2 = BoolOption('opt2', '', callback=return_value, callback_params=Params(ParamOption(opt1)), properties=('disabled',))
    od1 = OptionDescription('od1', '', [opt1])
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    raises(PropertiesOptionError, "cfg.option('od2.opt2').value.get()")


def test_callback_two_disabled2():
    opt1 = BoolOption('opt1', '', properties=('hidden',))
    opt2 = BoolOption('opt2', '', callback=return_value, callback_params=Params(ParamOption(opt1)), properties=('hidden',))
    od1 = OptionDescription('od1', '', [opt1])
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg.permissive.set(frozenset(['hidden']))
    raises(PropertiesOptionError, "cfg.option('od2.opt2').value.get()")
    assert cfg.forcepermissive.option('od2.opt2').owner.isdefault()


def test_callback_calculating_invalid():
    opt1 = IntOption('opt1', '', 1)
    opt2 = BoolOption('opt2', '', callback=return_value, callback_params=Params(ParamOption(opt1)))
    od1 = OptionDescription('od1', '', [opt1])
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    raises(ValueError, "cfg.option('od2.opt2').value.get()")
    cfg.unrestraint.option('od2.opt2').property.add('disabled')
    raises(PropertiesOptionError, "cfg.option('od2.opt2').value.get()")


def test_callback_calculating_disabled():
    opt1 = BoolOption('opt1', '', properties=('disabled',))
    opt2 = BoolOption('opt2', '', callback=return_value, callback_params=Params(ParamOption(opt1)))
    od1 = OptionDescription('od1', '', [opt1])
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    raises(ConfigError, "cfg.option('od2.opt2').value.get()")


def test_callback_calculating_mandatory():
    opt1 = BoolOption('opt1', '', properties=('disabled',))
    opt2 = BoolOption('opt2', '', callback=return_value, callback_params=Params(ParamOption(opt1)), properties=('mandatory',))
    od1 = OptionDescription('od1', '', [opt1])
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.property.read_only()
    raises(ConfigError, "cfg.option('od2.opt2').value.get()")


def test_callback_calculating_mandatory_multi():
    opt1 = BoolOption('opt1', '', multi=True, properties=('disabled',))
    opt2 = BoolOption('opt2', '', multi=True, callback=return_value, callback_params=Params(ParamOption(opt1)), properties=('mandatory',))
    od1 = OptionDescription('od1', '', [opt1])
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.property.read_only()
    raises(ConfigError, "cfg.option('od2.opt2').value.get()")


def test_callback_two_disabled_multi():
    opt1 = BoolOption('opt1', '', properties=('disabled',))
    opt2 = BoolOption('opt2', '', callback=return_value, callback_params=Params(ParamOption(opt1)), properties=('disabled',), multi=True)
    od1 = OptionDescription('od1', '', [opt1])
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    raises(PropertiesOptionError, "cfg.option('od2.opt2').value.get()")


def test_callback_multi_list_params(config_type):
    val1 = StrOption('val1', "", multi=True, default=['val1', 'val2'])
    val2 = StrOption('val2', "", multi=True, callback=return_list, callback_params=Params(ParamOption(val1)))
    oval2 = OptionDescription('val2', '', [val2])
    maconfig = OptionDescription('rootconfig', '', [val1, oval2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val2.val2').value.get() == ['val', 'val']


def test_callback_multi_list_params_key(config_type):
    val1 = StrOption('val1', "", multi=True, default=['val1', 'val2'])
    val2 = StrOption('val2', "", multi=True, callback=return_list, callback_params=Params(kwargs={'value': ParamOption(val1)}))
    oval2 = OptionDescription('val2', '', [val2])
    maconfig = OptionDescription('rootconfig', '', [val1, oval2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.option('val2.val2').value.get() == ['val', 'val']


def test_leadership_callback_description(config_type):
    st1 = StrOption('st1', "", multi=True)
    st2 = StrOption('st2', "", multi=True, callback=return_value, callback_params=Params(ParamOption(st1)))
    stm = Leadership('st1', '', [st1, st2])
    st = OptionDescription('st', '', [stm])
    od = OptionDescription('od', '', [st])
    od2 = OptionDescription('od', '', [od])
    cfg = Config(od2)
    cfg = get_config(cfg, config_type)
    owner = cfg.owner.get()
    assert cfg.option('od.st.st1.st1').value.get() == []
    assert cfg.option('od.st.st1.st1').owner.isdefault()
    ##
    cfg.option('od.st.st1.st1').value.set(['yes'])
    cfg.option('od.st.st1.st2', 0).value.set('yes')
    assert cfg.option('od.st.st1.st1').owner.get() == owner
    assert cfg.option('od.st.st1.st2', 0).owner.get() == owner


def test_callback_raise():
    opt1 = BoolOption('opt1', 'Option 1', callback=return_raise)
    opt2 = BoolOption('opt2', 'Option 2', callback=return_valueerror)
    od1 = OptionDescription('od1', '', [opt1])
    od2 = OptionDescription('od2', '', [opt2])
    maconfig = OptionDescription('rootconfig', '', [od1, od2])
    cfg = Config(maconfig)
    cfg.property.read_write()
    try:
        cfg.option('od1.opt1').value.get()
    except ConfigError as err:
        assert '"Option 1"' in str(err)
    try:
        cfg.option('od2.opt2').value.get()
    except ConfigError as err:
        assert '"Option 2"' in str(err)


def test_calc_value_simple(config_type):
    val1 = StrOption('val1', '', 'val1')
    val2 = StrOption('val2', '', callback=calc_value, callback_params=Params(ParamOption(val1)))
    od = OptionDescription('root', '', [val1, val2])
    cfg = Config(od)
    cfg = get_config(cfg, config_type)
    assert cfg.value.dict() == {'val1': 'val1', 'val2': 'val1'}


def test_calc_value_multi(config_type):
    val1 = StrOption('val1', "", 'val1')
    val2 = StrOption('val2', "", 'val2')
    val3 = StrOption('val3', "", multi=True, callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2)), multi=ParamValue(True)))
    od = OptionDescription('root', '', [val1, val2, val3])
    cfg = Config(od)
    cfg = get_config(cfg, config_type)
    assert cfg.value.dict() == {'val1': 'val1', 'val2': 'val2', 'val3': ['val1', 'val2']}


def test_calc_value_disabled():
    val1 = StrOption('val1', '', 'val1')
    val2 = StrOption('val2', '', callback=calc_value, callback_params=Params(ParamOption(val1, True), default=ParamValue('default_value')))
    od = OptionDescription('root', '', [val1, val2])
    cfg = Config(od)
    cfg.property.read_write()
    assert cfg.value.dict() == {'val1': 'val1', 'val2': 'val1'}
    cfg.option('val1').property.add('disabled')
    assert cfg.value.dict() == {'val2': 'default_value'}


def test_calc_value_condition(config_type):
    boolean = BoolOption('boolean', '', True)
    val1 = StrOption('val1', '', 'val1')
    val2 = StrOption('val2', '', callback=calc_value, callback_params=Params(ParamOption(val1, True),
                                                                             default=ParamValue('default_value'),
                                                                             condition=ParamOption(boolean),
                                                                             expected=ParamValue(True)))
    od = OptionDescription('root', '', [boolean, val1, val2])
    cfg = Config(od)
    cfg.property.read_write()
    cfg = get_config(cfg, config_type)
    assert cfg.value.dict() == {'boolean': True, 'val1': 'val1', 'val2': 'val1'}
    cfg.option('boolean').value.set(False)
    assert cfg.value.dict() == {'boolean': False, 'val1': 'val1', 'val2': 'default_value'}


def test_calc_value_allow_none(config_type):
    val1 = StrOption('val1', "", 'val1')
    val2 = StrOption('val2', "")
    val3 = StrOption('val3', "", multi=True, callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2)), multi=ParamValue(True), allow_none=ParamValue(True)))
    od = OptionDescription('root', '', [val1, val2, val3])
    cfg = Config(od)
    cfg = get_config(cfg, config_type)
    assert cfg.value.dict() == {'val1': 'val1', 'val2': None, 'val3': ['val1', None]}


def test_calc_value_remove_duplicate(config_type):
    val1 = StrOption('val1', "", 'val1')
    val2 = StrOption('val2', "", 'val1')
    val3 = StrOption('val3', "", multi=True, callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2)), multi=ParamValue(True), remove_duplicate_value=ParamValue(True)))
    od = OptionDescription('root', '', [val1, val2, val3])
    cfg = Config(od)
    cfg = get_config(cfg, config_type)
    assert cfg.value.dict() == {'val1': 'val1', 'val2': 'val1', 'val3': ['val1']}


def test_calc_value_join(config_type):
    val1 = StrOption('val1', "", 'val1')
    val2 = StrOption('val2', "", 'val2')
    val3 = StrOption('val3', "", callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2)), join=ParamValue('.')))
    od = OptionDescription('root', '', [val1, val2, val3])
    cfg = Config(od)
    cfg = get_config(cfg, config_type)
    assert cfg.value.dict() == {'val1': 'val1', 'val2': 'val2', 'val3': 'val1.val2'}


def test_calc_value_min():
    val1 = StrOption('val1', "", 'val1')
    val2 = StrOption('val2', "", 'val2')
    val3 = StrOption('val3', "", 'val3')
    val4 = StrOption('val4', "", callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2), ParamOption(val3, True)), join=ParamValue('.'), min_args_len=ParamValue(3)))
    od = OptionDescription('root', '', [val1, val2, val3, val4])
    cfg = Config(od)
    cfg.property.read_write()
    assert cfg.value.dict() == {'val1': 'val1', 'val2': 'val2', 'val3': 'val3', 'val4': 'val1.val2.val3'}
    cfg.option('val3').property.add('disabled')
    assert cfg.value.dict() == {'val1': 'val1', 'val2': 'val2', 'val4': ''}


def test_calc_value_add(config_type):
    val1 = IntOption('val1', "", 1)
    val2 = IntOption('val2', "", 2)
    val3 = IntOption('val3', "", callback=calc_value, callback_params=Params((ParamOption(val1), ParamOption(val2)), operator=ParamValue('add')))
    od = OptionDescription('root', '', [val1, val2, val3])
    cfg = Config(od)
    cfg = get_config(cfg, config_type)
    assert cfg.value.dict() == {'val1': 1, 'val2': 2, 'val3': 3}