tiramisu/test/api/test_owner.py

"""test API
"""
import weakref
import pytest
from copy import copy
from py.test import raises
from .autopath import do_autopath
do_autopath()
from tiramisu import Config, MetaConfig, \
                     StrOption, OptionDescription, MasterSlaves, DynOptionDescription, \
                     getapi, submulti, undefined
from tiramisu.error import PropertiesOptionError, APIError, ConfigError
from collections import OrderedDict
ICON = u'\u2937'

OPTIONS_TYPE = {'str': {'type': str,
                        'option': StrOption}
               }
PROPERTIES = ['hidden', 'disabled']
PROPERTIES_LIST = ['prop1', 'prop2']

OWNER = 'user'

# multi is False
FIRST_VALUE = 'myvalue'
SECOND_VALUE = 'myvalue1'
EMPTY_VALUE = None
# multi is True
LIST_FIRST_VALUE = ['myvalue']
LIST_SECOND_VALUE = ['myvalue', 'myvalue1']
LIST_EMPTY_VALUE = []
# multi is submulti
SUBLIST_FIRST_VALUE = [['myvalue']]
SUBLIST_SECOND_VALUE = [['myvalue'], ['myvalue1', 'myvalue2']]
SUBLIST_EMPTY_VALUE = []

DISPLAY = True
DISPLAY = False


def return_list(val=None, suffix=None):
    if val:
        return val
    else:
        return ['val1', 'val2']


def display_info(func):
    def wrapper(*args, **kwargs):
        if DISPLAY:
            print(u'\n{} {}'.format(ICON, func.__name__))
        return func(*args, **kwargs)
    return wrapper


autocheck_registers = []


def autocheck(func):
    autocheck_registers.append(func)
    def wrapper(*args, **kwargs):
        if DISPLAY and kwargs.get('display', True):
            print(u'  {} {}'.format(ICON, func.__name__))
        return func(*args, **kwargs)
    return wrapper


@autocheck
def autocheck_option_multi(api, path, **kwargs):
    if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
        api.option(path).option.ismulti()
        api.option(path).option.issubmulti()
        api.option(path).option.ismaster()
        api.option(path).option.isslave()
        #
        api.forcepermissive.option(path).option.ismulti()
        api.forcepermissive.option(path).option.issubmulti()
        api.forcepermissive.option(path).option.ismaster()
        api.forcepermissive.option(path).option.isslave()
        #
        api.unrestraint.option(path).option.ismulti()
        api.unrestraint.option(path).option.issubmulti()
        api.unrestraint.option(path).option.ismaster()
        api.unrestraint.option(path).option.isslave()
    elif not kwargs.get('propertyerror', False):
        raises(PropertiesOptionError, "api.option(path).option.ismulti()")
        raises(PropertiesOptionError, "api.option(path).option.issubmulti()")
        raises(PropertiesOptionError, "api.option(path).option.ismaster()")
        raises(PropertiesOptionError, "api.option(path).option.isslave()")
        #
        api.forcepermissive.option(path).option.ismulti()
        api.forcepermissive.option(path).option.issubmulti()
        api.forcepermissive.option(path).option.ismaster()
        api.forcepermissive.option(path).option.isslave()
        #
        api.unrestraint.option(path).option.ismulti()
        api.unrestraint.option(path).option.issubmulti()
        api.unrestraint.option(path).option.ismaster()
        api.unrestraint.option(path).option.isslave()
    else:
        raises(PropertiesOptionError, "api.option(path).option.ismulti()")
        raises(PropertiesOptionError, "api.option(path).option.issubmulti()")
        raises(PropertiesOptionError, "api.option(path).option.ismaster()")
        raises(PropertiesOptionError, "api.option(path).option.isslave()")
        #
        raises(PropertiesOptionError, "api.forcepermissive.option(path).option.ismulti()")
        raises(PropertiesOptionError, "api.forcepermissive.option(path).option.issubmulti()")
        raises(PropertiesOptionError, "api.forcepermissive.option(path).option.ismaster()")
        raises(PropertiesOptionError, "api.forcepermissive.option(path).option.isslave()")
        #
        api.unrestraint.option(path).option.ismulti()
        api.unrestraint.option(path).option.issubmulti()
        api.unrestraint.option(path).option.ismaster()
        api.unrestraint.option(path).option.isslave()


@autocheck
def autocheck_default_owner(api, path, **kwargs):
    """check different value of owner when any value is set to this option
    """
    isslave = api.unrestraint.option(path).option.isslave()
    # check if owner is a string "default" and 'isdefault'
    if not isslave:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path).owner.get() == 'default'
            assert api.forcepermissive.option(path).owner.get() == 'default'
            #
            assert api.option(path).owner.isdefault()
            assert api.forcepermissive.option(path).owner.isdefault()
        elif not kwargs.get('propertyerror', False):
            raises(PropertiesOptionError, "api.option(path).owner.get()")
            assert api.forcepermissive.option(path).owner.get() == 'default'
            #
            raises(PropertiesOptionError, "api.option(path).owner.isdefault()")
            assert api.forcepermissive.option(path).owner.isdefault()
        else:
            raises(PropertiesOptionError, "api.option(path).owner.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.get()")
            #
            raises(PropertiesOptionError, "api.option(path).owner.isdefault()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.isdefault()")
    else:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path, 0).owner.get() == 'default'
            assert api.forcepermissive.option(path, 0).owner.get() == 'default'
            #
            assert api.option(path, 0).owner.isdefault()
            assert api.forcepermissive.option(path, 0).owner.isdefault()
        elif not kwargs.get('propertyerror', False):
            raises(PropertiesOptionError, "api.option(path, 0).owner.get()")
            assert api.forcepermissive.option(path, 0).owner.get() == 'default'
            #
            assert api.option(path, 0).owner.isdefault()
            raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.isdefault()")
        else:
            raises(PropertiesOptionError, "api.option(path, 0).owner.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.get()")
            #
            raises(PropertiesOptionError, "api.option(path, 0).owner.isdefault()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.isdefault()")

    # unrestraint is not allowed
    raises(APIError, "api.unrestraint.option(path).owner.get()")
    raises(APIError, "api.unrestraint.option(path).owner.isdefault()")


def _getdefault(api, path, multi, isslave, submulti_):
    empty_value = api.unrestraint.option(path).option.getdefault()
    if isslave and empty_value == []:
        empty_value = api.unrestraint.option(path).option.getdefaultmulti()
    return empty_value


def _autocheck_default_value(api, path, **kwargs):
    """set and get values
    """
    # check if is a multi, a master or a slave
    multi = api.unrestraint.option(path).option.ismulti()
    submulti_ = api.unrestraint.option(path).option.issubmulti()
    isslave = api.unrestraint.option(path).option.isslave()

    # set default value (different if value is multi or not)
    empty_value = _getdefault(api, path, multi, isslave, submulti_)

    # test default value (should be empty)
    # cannot test for slave (we cannot get all values for a slave)
    if not isslave:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path).value.get() == empty_value
            assert api.forcepermissive.option(path).value.get() == empty_value
        elif not kwargs.get('propertyerror', False):
            raises(PropertiesOptionError, "api.option(path).value.get()")
            assert api.forcepermissive.option(path).value.get() == empty_value
        else:
            raises(PropertiesOptionError, "api.option(path).value.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()")
    else:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path, 0).value.get() == empty_value
            assert api.option(path, 1).value.get() == empty_value
            assert api.forcepermissive.option(path, 0).value.get() == empty_value
            assert api.forcepermissive.option(path, 1).value.get() == empty_value
        elif not kwargs.get('propertyerror', False):
            raises(PropertiesOptionError, "api.option(path, 0).value.get()")
            assert api.forcepermissive.option(path, 0).value.get() == empty_value
            assert api.forcepermissive.option(path, 1).value.get() == empty_value
        else:
            raises(PropertiesOptionError, "api.option(path, 0).value.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()")


@autocheck
def autocheck_default_value(api, path, **kwargs):
    _autocheck_default_value(api, path, **kwargs)


def _autocheck_set_value(api, path, **kwargs):
    set_permissive = kwargs.get('set_permissive', True)
    multi = api.unrestraint.option(path).option.ismulti()
    submulti_ = api.unrestraint.option(path).option.issubmulti()
    ismaster = api.unrestraint.option(path).option.ismaster()
    isslave = api.unrestraint.option(path).option.isslave()
    if not multi:
        first_value = FIRST_VALUE
    elif submulti_ is False:
        first_value = LIST_FIRST_VALUE
    else:
        first_value = SUBLIST_FIRST_VALUE

    # for slave should have an index and good length
    # for master must append, not set
    if ismaster:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            raises(APIError, "api.option(path, 0).value.set(first_value[0])")
            if not set_permissive:
                api.option(path).value.set([first_value[0]])
            else:
                api.forcepermissive.option(path).value.set([first_value[0]])
        elif not kwargs.get('propertyerror', False):
            raises(PropertiesOptionError, "api.option(path).value.set([first_value[0]])")
            if set_permissive:
                api.forcepermissive.option(path).value.set([first_value[0]])
        else:
            raises(PropertiesOptionError, "api.option(path).value.set([first_value[0]])")
            raises(PropertiesOptionError,
                   "api.forcepermissive.option(path).value.set([first_value[0]])")
        raises(APIError, "api.unrestraint.option(path).value.set(first_value[1])")
    elif isslave:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            if not set_permissive:
                api.option(path, 0).value.set(first_value[0])
            else:
                api.forcepermissive.option(path, 0).value.set(first_value[0])
        elif not kwargs.get('propertyerror', False):
            raises(PropertiesOptionError, "api.option(path, 0).value.set(first_value[0])")
            if set_permissive:
                api.forcepermissive.option(path, 0).value.set(first_value[0])
        else:
            raises(PropertiesOptionError, "api.option(path, 0).value.set(first_value[0])")
            raises(PropertiesOptionError,
                   "api.forcepermissive.option(path, 0).value.set(first_value[0])")
        raises(APIError,
               "api.unrestraint.option(path).value.set([first_value[0], first_value[1]])")

    else:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            if not set_permissive:
                api.option(path).value.set(first_value)
            else:
                api.forcepermissive.option(path).value.set(first_value)
        elif not kwargs.get('propertyerror', False):
            raises(PropertiesOptionError, "api.option(path).value.set(first_value)")
            if set_permissive:
                api.forcepermissive.option(path).value.set(first_value)
        else:
            raises(PropertiesOptionError, "api.option(path).value.set(first_value)")
            raises(PropertiesOptionError, "api.forcepermissive.option(path).value.set(first_value)")
        raises(APIError, "api.unrestraint.option(path).value.set(first_value)")


@autocheck
def autocheck_set_value(api, path, **kwargs):
    _autocheck_set_value(api, path, **kwargs)


@autocheck
def autocheck_get_value_permissive(api, path, **kwargs):
    multi = api.unrestraint.option(path).option.ismulti()
    submulti_ = api.unrestraint.option(path).option.issubmulti()
    isslave = api.unrestraint.option(path).option.isslave()
    _autocheck_set_value(api, path, **kwargs)
    if not multi:
        first_value = FIRST_VALUE
    elif submulti_ is False:
        first_value = LIST_FIRST_VALUE
    else:
        first_value = SUBLIST_FIRST_VALUE

    # get value after set value without permissive
    if isslave:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path, 0).value.get() == first_value[0]
            assert api.forcepermissive.option(path, 0).value.get() == first_value[0]
        elif kwargs.get('permissive', False):
            raises(PropertiesOptionError, "api.option(path, 0).value.get()")
            assert api.forcepermissive.option(path, 0).value.get() == first_value
        else:
            raises(PropertiesOptionError, "api.option(path, 0).value.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()")
    else:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path).value.get() == first_value
            assert api.forcepermissive.option(path).value.get() == first_value
        elif kwargs.get('permissive', False):
            raises(PropertiesOptionError, "api.option(path).value.get()")
            assert api.forcepermissive.option(path).value.get() == first_value
        else:
            raises(PropertiesOptionError, "api.option(path).value.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()")


def _autocheck_get_value(api, path, **kwargs):
    multi = api.unrestraint.option(path).option.ismulti()
    submulti_ = api.unrestraint.option(path).option.issubmulti()
    isslave = api.unrestraint.option(path).option.isslave()
    empty_value = _getdefault(api, path, multi, isslave, submulti_)
    if not multi:
        first_value = FIRST_VALUE
    elif submulti_ is False:
        first_value = LIST_FIRST_VALUE
    else:
        first_value = SUBLIST_FIRST_VALUE

    # get value after set value without permissive
    if isslave:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path, 0).value.get() == first_value[0]
            assert api.forcepermissive.option(path, 0).value.get() == first_value[0]
        elif kwargs.get('permissive', False):
            raises(PropertiesOptionError, "api.option(path, 0).value.get()")
            assert api.forcepermissive.option(path, 0).value.get() == empty_value
        else:
            raises(PropertiesOptionError, "api.option(path, 0).value.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()")
    else:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path).value.get() == first_value
            assert api.forcepermissive.option(path).value.get() == first_value
        elif kwargs.get('permissive', False):
            raises(PropertiesOptionError, "api.option(path).value.get()")
            assert api.forcepermissive.option(path).value.get() == empty_value
        else:
            raises(PropertiesOptionError, "api.option(path).value.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()")


@autocheck
def autocheck_get_value(api, path, **kwargs):
    _autocheck_set_value(api, path, set_permissive=False, **kwargs)
    _autocheck_get_value(api, path, **kwargs)


@autocheck
def autocheck_value_slave(api, path, **kwargs):
    isslave = api.unrestraint.option(path).option.isslave()
    if not isslave:
        #FIXME raises(APIError, "api.option(path).value.len()")
        return
    if kwargs.get('propertyerror', False):
        raises(PropertiesOptionError, "api.option(path).value.len()")
        raises(PropertiesOptionError, "api.forcepermissive.option(path).value.len()")
        return

    multi = api.unrestraint.option(path).option.ismulti()
    submulti_ = api.forcepermissive.option(path).option.issubmulti()
    if not submulti_:
        second_value = LIST_SECOND_VALUE
    else:
        second_value = SUBLIST_SECOND_VALUE
    empty_value = _getdefault(api, path, multi, isslave, submulti_)

    if not kwargs.get('permissive', False):
        length = api.option(path).value.len()
        assert api.forcepermissive.option(path).value.len() == length
    else:
        raises(PropertiesOptionError, "api.option(path).value.len()")
        length = api.forcepermissive.option(path).value.len()

    assert length == 2

    value = []
    for idx in range(length):
        value.append(api.forcepermissive.option(path, idx).value.get())

    assert value == [empty_value, second_value[1]]
    # cannot access to a slave with index too high
    if submulti_ is False:
        value = LIST_FIRST_VALUE[0]
    else:
        value = SUBLIST_FIRST_VALUE[0]

    raises(IndexError, "api.forcepermissive.option(path, length).value.get()")
    raises(IndexError, "api.forcepermissive.option(path, length).value.set(value)")
    raises(IndexError, "api.forcepermissive.option(path, length).value.reset()")
    raises(IndexError, "api.forcepermissive.option(path, length).owner.get()")
    raises(IndexError, "api.forcepermissive.option(path, length).owner.isdefault()")
    raises(IndexError, "api.forcepermissive.option(path, length).property.get()")
    raises(IndexError, "api.forcepermissive.option(path, length).owner.set('new_user')")
    raises(IndexError, "api.forcepermissive.option(path, length).property.set(('prop',))")


@autocheck
def autocheck_reset_value(api, path, **kwargs):
    # check if is a multi, a master or a slave
    multi = api.unrestraint.option(path).option.ismulti()
    submulti_ = api.unrestraint.option(path).option.issubmulti()
    isslave = api.unrestraint.option(path).option.isslave()

    # set default value (different if value is multi or not)
    if not multi:
        first_value = FIRST_VALUE
        second_value = SECOND_VALUE
    elif submulti_ is False:
        first_value = LIST_FIRST_VALUE
        second_value = LIST_SECOND_VALUE
    else:
        first_value = SUBLIST_FIRST_VALUE
        second_value = SUBLIST_SECOND_VALUE
    empty_value = _getdefault(api, path, multi, isslave, submulti_)
    _autocheck_set_value(api, path, **kwargs)

    # reset value without permissive
    if not isslave:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            api.option(path).value.reset()
        else:
            raises(PropertiesOptionError, "api.option(path).value.reset()")
    else:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            api.option(path, 0).value.reset()
        else:
            raises(PropertiesOptionError, "api.option(path, 0).value.reset()")

    # get value after reset value without permissive
    if isslave:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path, 0).value.get() == empty_value
            assert api.option(path, 1).value.get() == second_value[1]
        elif kwargs.get('permissive', False):
            raises(PropertiesOptionError, "api.option(path, 0).value.get()")
            assert api.forcepermissive.option(path, 0).value.get() == empty_value
            assert api.forcepermissive.option(path, 1).value.get() == second_value[1]
    else:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path).value.get() == empty_value
        elif kwargs.get('permissive', False):
            raises(PropertiesOptionError, "api.option(path).value.get()")
            assert api.forcepermissive.option(path).value.get() == first_value


@autocheck
def autocheck_reset_value_permissive(api, path, **kwargs):
    # check if is a multi, a master or a slave
    isslave = api.unrestraint.option(path).option.isslave()
    _autocheck_set_value(api, path, **kwargs)

    # reset value with permissive
    if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
        if not isslave:
            api.forcepermissive.option(path).value.reset()
        else:
            api.forcepermissive.option(path, 1).value.reset()
    elif kwargs.get('permissive', False):
        if not isslave:
            api.forcepermissive.option(path).value.reset()
        else:
            api.forcepermissive.option(path, 1).value.reset()
    else:
        if not isslave:
            raises(PropertiesOptionError, "api.forcepermissive.option(path).value.reset()")
        else:
            raises(PropertiesOptionError, "api.forcepermissive.option(path, 1).value.reset()")
    _autocheck_default_value(api, path, **kwargs)


@autocheck
def autocheck_display(api, path, **kwargs):
    """re set value
    """
    #FIXME make_dict?
    assert api.config
    _autocheck_set_value(api, path, **kwargs)
    assert api.config


def _getproperties(multi, isslave, kwargs):
    # define properties
    properties = copy(PROPERTIES_LIST)
    if multi and not isslave:
        default_props = ['empty']
        properties.append('empty')
    else:
        default_props = []
    extra_properties = kwargs.get('extra_properties')
    if extra_properties:
        properties.extend(extra_properties)
        default_props.extend(extra_properties)
    return default_props, frozenset(properties)


def _check_default_properties(api, path, kwargs, props_permissive, props):
    if not api.unrestraint.option(path).option.isslave():
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert set(api.option(path).property.get()) == set(props_permissive)
            assert set(api.forcepermissive.option(path).property.get()) == set(props_permissive)
        elif not kwargs.get('propertyerror', False):
            raises(PropertiesOptionError, "api.option(path).property.get()")
            assert set(api.forcepermissive.option(path).property.get()) == set(props)
        else:
            raises(PropertiesOptionError, "api.option(path).property.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path).property.get()")
        raises(APIError, "api.unrestraint.option(path).property.get()")
    else:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert set(api.option(path, 0).property.get()) == set(props)
            assert set(api.option(path, 1).property.get()) == set(props)
        else:
            raises(PropertiesOptionError, "api.option(path, 0).property.get()")
        raises(APIError, "api.unrestraint.option(path, 0).property.get()")


def _autocheck_property(api, path, **kwargs):
    """get property from path
    """
    # check if is a multi or a slave
    multi = api.unrestraint.option(path).option.ismulti()
    isslave = api.unrestraint.option(path).option.isslave()

    default_props, properties = _getproperties(multi, isslave, kwargs)

    _check_default_properties(api, path, kwargs, default_props, default_props)

    # set properties without permissive
    if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
        api.option(path).property.set(properties)
    else:
        raises(PropertiesOptionError, "api.option(path).property.set(properties)")

    _check_default_properties(api, path, kwargs, properties, default_props)


@autocheck
def autocheck_property(api, path, **kwargs):
    _autocheck_property(api, path, **kwargs)


def _property_permissive(api, path, **kwargs):
    # check if is a multi or a slave
    multi = api.unrestraint.option(path).option.ismulti()
    isslave = api.unrestraint.option(path).option.isslave()

    # define properties
    properties = copy(PROPERTIES_LIST)
    if multi and not isslave:
        default_props = ['empty']
        properties.append('empty')
    else:
        default_props = []
    extra_properties = kwargs.get('extra_properties')
    if extra_properties:
        properties.extend(extra_properties)
        default_props.extend(extra_properties)
    default_props, properties = _getproperties(multi, isslave, kwargs)

    _check_default_properties(api, path, kwargs, default_props, default_props)

    # set properties with permissive
    if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
        api.option(path).property.set(properties)
        api.forcepermissive.option(path).property.set(properties)
    elif not kwargs.get('propertyerror', False):
        raises(PropertiesOptionError, "api.option(path).property.set(properties)")
        api.forcepermissive.option(path).property.set(properties)
    else:
        raises(PropertiesOptionError, "api.option(path).property.set(properties)")
        raises(PropertiesOptionError, "api.forcepermissive.option(path).property.set(properties)")

    _check_default_properties(api, path, kwargs, properties, properties)


@autocheck
def autocheck_property_permissive(api, path, **kwargs):
    _property_permissive(api, path, **kwargs)


@autocheck
def autocheck_reset_property(api, path, **kwargs):
    """check properties after set with permissive
    """
    # check if is a multi or a slave
    multi = api.unrestraint.option(path).option.ismulti()
    isslave = api.unrestraint.option(path).option.isslave()
    default_props, properties = _getproperties(multi, isslave, kwargs)

    _property_permissive(api, path, **kwargs)

    # reset properties without permissive
    if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
        api.option(path).property.reset()
    else:
        raises(PropertiesOptionError, "api.option(path).property.reset()")

    _check_default_properties(api, path, kwargs, default_props, properties)


@autocheck
def autocheck_reset_property_permissive(api, path, **kwargs):
    # check if is a multi or a slave
    multi = api.unrestraint.option(path).option.ismulti()
    isslave = api.unrestraint.option(path).option.isslave()
    default_props, properties = _getproperties(multi, isslave, kwargs)

    _property_permissive(api, path, **kwargs)

    # reset properties with permissive
    raises(APIError, "api.unrestraint.option(path).property.set(properties)")
    raises(APIError, "api.unrestraint.option(path).property.reset()")
    if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
        api.forcepermissive.option(path).property.set(properties)
        api.forcepermissive.option(path).property.reset()
    elif kwargs.get('permissive', False):
        api.forcepermissive.option(path).property.reset()

    _check_default_properties(api, path, kwargs, default_props, default_props)


@autocheck
def autocheck_context_owner(api, path, **kwargs):
    owner = api.owner.get()
    assert owner == OWNER


def _check_owner(api, path, kwargs, owner, permissive_owner):
    isslave = api.unrestraint.option(path).option.isslave()
    if not isslave:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path).owner.get() == owner
            assert api.forcepermissive.option(path).owner.get() == owner
        elif not kwargs.get('propertyerror', False):
            raises(PropertiesOptionError, "api.option(path).owner.get()")
            assert api.forcepermissive.option(path).owner.get() == permissive_owner
        else:
            raises(PropertiesOptionError, "api.option(path).owner.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.get()")
    else:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            assert api.option(path, 0).owner.get() == 'default'
            assert api.option(path, 1).owner.get() == owner
            assert api.forcepermissive.option(path, 0).owner.get() == 'default'
            assert api.forcepermissive.option(path, 1).owner.get() == owner
        elif not kwargs.get('propertyerror', False):
            raises(PropertiesOptionError, "api.option(path, 0).owner.get()")
            raises(PropertiesOptionError, "api.option(path, 1).owner.get()")
            assert api.forcepermissive.option(path, 0).owner.get() == 'default'
            assert api.forcepermissive.option(path, 1).owner.get() == permissive_owner
        else:
            raises(PropertiesOptionError, "api.option(path, 0).owner.get()")
            raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.get()")


@autocheck
def autocheck_owner_with_value(api, path, **kwargs):
    """value is now changed, check owner in this case
    """
    _autocheck_set_value(api, path, **kwargs)
    _check_owner(api, path, kwargs, OWNER, OWNER)


@autocheck
def autocheck_default_owner_with_value(api, path, **kwargs):
    _autocheck_set_value(api, path, **kwargs)
    # check if is a isslave
    isslave = api.unrestraint.option(path).option.isslave()

    # test if is default owner without permissive
    if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
        assert api.option(path).owner.isdefault() is False
    else:
        raises(PropertiesOptionError, "api.option(path).owner.isdefault()")


@autocheck
def autocheck_default_owner_with_value_permissive(api, path, **kwargs):
    # check if is a isslave
    isslave = api.unrestraint.option(path).option.isslave()

    _autocheck_set_value(api, path, **kwargs)

    # test if is default owner with permissive
    if not kwargs.get('propertyerror', False):
        if not isslave:
            assert api.forcepermissive.option(path).owner.isdefault() is False
        else:
            assert api.forcepermissive.option(path, 0).owner.isdefault() is True
            assert api.forcepermissive.option(path, 1).owner.isdefault() is False
    else:
        raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.isdefault()")


@autocheck
def autocheck_set_owner_no_value(api, path, **kwargs):
    isslave = api.unrestraint.option(path).option.isslave()
    if not kwargs.get('propertyerror', False):
        if not isslave:
            raises(ConfigError, "api.forcepermissive.option(path).owner.set('new_user')")
        else:
            raises(ConfigError, "api.forcepermissive.option(path, 1).owner.set('new_user')")


@autocheck
def autocheck_set_owner(api, path, **kwargs):
    # test set owner without permissive
    isslave = api.unrestraint.option(path).option.isslave()

    _autocheck_set_value(api, path, **kwargs)

    # set owner without permissive
    if not isslave:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            api.option(path).owner.set('new_user')
        else:
            raises(PropertiesOptionError, "api.option(path).owner.set('new_user')")
    else:
        if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
            api.option(path, 1).owner.set('new_user')
        else:
            raises(PropertiesOptionError, "api.option(path, 1).owner.set('new_user')")

    _check_owner(api, path, kwargs, 'new_user', OWNER)


@autocheck
def autocheck_set_owner_permissive(api, path, **kwargs):
    isslave = api.unrestraint.option(path).option.isslave()

    _autocheck_set_value(api, path, **kwargs)

    # set owner with permissive
    if not kwargs.get('propertyerror', False):
        if not isslave:
            api.forcepermissive.option(path).owner.set('new_user1')
        else:
            api.forcepermissive.option(path, 1).owner.set('new_user1')
    else:
        if not isslave:
            raises(PropertiesOptionError,
                   "api.forcepermissive.option(path).owner.set('new_user1')")
        else:
            raises(PropertiesOptionError,
                   "api.forcepermissive.option(path, 1).owner.set('new_user1')")

    _check_owner(api, path, kwargs, 'new_user1', 'new_user1')


@autocheck
def autocheck_option(api, path, **kwargs):
    expected_name = path.split('.')[-1]
    if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
        current_name = api.option(path).option.getname()
        assert current_name == api.forcepermissive.option(path).option.getname()
        assert current_name == api.unrestraint.option(path).option.getname()
        doc = api.option(path).option.getdoc()
        assert doc == api.forcepermissive.option(path).option.getdoc()
        assert doc == api.unrestraint.option(path).option.getdoc()
    elif not kwargs.get('propertyerror', False):
        raises(PropertiesOptionError, "api.option(path).option.getname()")
        current_name = api.forcepermissive.option(path).option.getname()
        assert current_name == api.unrestraint.option(path).option.getname()
        raises(PropertiesOptionError, "api.option(path).option.getdoc()")
        doc = api.forcepermissive.option(path).option.getdoc()
        assert doc == api.unrestraint.option(path).option.getdoc()
    else:
        raises(PropertiesOptionError, "api.option(path).option.getname()")
        raises(PropertiesOptionError, "api.forcepermissive.option(path).option.getname()")
        current_name = api.unrestraint.option(path).option.getname()
        raises(PropertiesOptionError, "api.option(path).option.getdoc()")
        raises(PropertiesOptionError, "api.forcepermissive.option(path).option.getdoc()")
        doc = api.unrestraint.option(path).option.getdoc()
    assert current_name == expected_name
    if expected_name.endswith('val1') or expected_name.endswith('val2'):
        expected_name = expected_name[:-4]
    assert doc == "{}'s option".format(expected_name)


@autocheck
def autocheck_permissive(api, path, **kwargs):
    """test permissive for hidden and disabled value
    """
    # no permissive before
    assert api.unrestraint.option(path).permissive.get() == frozenset()
    if kwargs.get('permissive_od', False):
        assert api.unrestraint.option(path.rsplit('.', 1)[0]).permissive.get() == frozenset()

    # cannot access to hidden value without forcepermissive
    # and to disabled value (with forcepermissive too)
    _autocheck_default_value(api, path, **kwargs)

    # set permissive
    api.unrestraint.option(path).permissive.set(frozenset(['disabled']))

    # have permissive
    assert api.unrestraint.option(path).permissive.get() == frozenset(['disabled'])

    # can access to disabled value
    ckwargs = copy(kwargs)
    ckwargs['propertyerror'] = False
    _autocheck_default_value(api, path, **ckwargs)

    api.unrestraint.option(path).permissive.set(frozenset(['disabled', 'hidden']))

    # can access to all value except when optiondescript have hidden
    if not ckwargs.get('permissive_od', False):
        ckwargs['permissive'] = False
    _autocheck_default_value(api, path, **ckwargs)

    if ckwargs.get('permissive_od', False):
        # set permissive to OptionDescription
        api.unrestraint.option(path.rsplit('.', 1)[0]).permissive.set(frozenset(['disabled',
                                                                                 'hidden']))
        ckwargs['permissive'] = False
        _autocheck_default_value(api, path, **ckwargs)

    # only hidden
    api.unrestraint.option(path).permissive.set(frozenset(['hidden']))
    if ckwargs.get('permissive_od', False):
        _autocheck_default_value(api, path, **ckwargs)
        api.unrestraint.option(path.rsplit('.', 1)[0]).permissive.set(frozenset(['hidden']))
    ckwargs = copy(kwargs)
    ckwargs['permissive'] = False
    _autocheck_default_value(api, path, **ckwargs)

    # no permissive
    api.unrestraint.option(path).permissive.set(frozenset())
    if ckwargs.get('permissive_od', False):
        _autocheck_default_value(api, path, **ckwargs)
        api.unrestraint.option(path.rsplit('.', 1)[0]).permissive.set(frozenset())
    _autocheck_default_value(api, path, **kwargs)



def check_all(cfg, path, meta, multi, default, default_multi, require, consistency, **kwargs):
    if DISPLAY:
        text = u' {} launch tests for {}'.format(ICON, path)
        if multi is True:
            text += u' as a multi'
        elif multi is submulti:
            text += u' as a submulti'
        if default is True:
            text += u' with default'
        if multi is True:
            text += u' with default value'
        if default_multi is True:
            text += u' with default multi'
        text += u', kwargs: {}'.format(kwargs)
        print(text)
    api = getapi(cfg)
    if api.unrestraint.option(path).option.isslave():
        master_path = path.rsplit('.', 1)[0] + '.master'
        api.option(master_path).value.set(LIST_SECOND_VALUE)
    if not require:
        requires = [False]
    else:
        requires = [False, True]
    for req in requires:
        for func in autocheck_registers:
            api = getapi(cfg.duplicate())
            #FIXME devrait etre dans la config ca ...
            api.read_write()
            ckwargs = copy(kwargs)
            if req:
                api.option('extraoptrequire').value.set('value')
                if 'permissive' in ckwargs and not 'permissive_od' in ckwargs or \
                        'propertyerror' in ckwargs and not 'propertyerror_od' in ckwargs:
                    for to_del in ['permissive', 'propertyerror', 'extra_properties']:
                        if to_del in ckwargs:
                            del ckwargs[to_del]
            if DISPLAY:
                print(u'  {} {}'.format(ICON, func.__name__))
            try:
                func(api, path, **ckwargs)
            except Exception as err:
                msg = u'error in function {} for {}'.format(func.__name__, path)
                if multi is True:
                    msg += u' as a multi'
                elif multi is submulti:
                    msg += u' as a submulti'
                if multi is True:
                    msg += u' with default value'
                print(u'{}: {}'.format(msg, ckwargs))
                raise err


def check_deref(weakrefs):
    """try if all elements are dereferenced
    """
    for wrf in weakrefs:
        assert wrf() is None


def make_conf(options, meta, multi, default, default_multi, require, consistency):
    weakrefs = []
    dyn = []
    goptions = []
    def make_option(path, option_infos):
        #FIXME
        option_type = 'str'
        option_properties = []
        option_requires = []
        isslave = False
        if option_infos is not None:
            for prop in PROPERTIES:
                if option_infos.get(prop, False) is True:
                    if not require:
                        option_properties.append(prop)
                    else:
                        option_requires.append({'option': goptions[0], 'expected': None,
                                                'action': prop})
            isslave = option_infos.get('slave', False)
        args = [path, "{}'s option".format(path)]
        kwargs = {}
        if option_properties != []:
            kwargs['properties'] = tuple(option_properties)
        if option_requires != []:
            kwargs['requires'] = option_requires
        if multi and path is not 'extraoptrequire':
            kwargs['multi'] = multi
        if default and not submulti:
            if multi is False:
                value = FIRST_VALUE
            elif multi is True:
                value = LIST_FIRST_VALUE
            else:
                value = SUBLIST_EMPTY_VALUE
            kwargs['default'] = value
        if default_multi and path is not 'extraoptrequire':
            if multi is not submulti:
                value = SECOND_VALUE
            else:
                value = LIST_SECOND_VALUE
            kwargs['default_multi'] = value

        tiramisu_option = OPTIONS_TYPE[option_type]['option']
        obj = tiramisu_option(*args, **kwargs)
        if not 'extraopt' in path and consistency:
            if require:
                gopt = goptions[1]
            else:
                gopt = goptions[0]
            obj.impl_add_consistency('not_equal', gopt, warnings_only=True)
        weakrefs.append(weakref.ref(obj))
        return obj

    def make_optiondescriptions(path, collected):
        infos = collected.get('properties', {})
        properties = []
        kwargs = {}
        optiondescription = OptionDescription

        for prop in PROPERTIES:
            if infos.get(prop, False) is True:
                properties.append(prop)
        if infos.get('master', False) is True:
            if not multi:
                return
            optiondescription = MasterSlaves
        if infos.get('dyn', False) is True:
            optiondescription = DynOptionDescription
            kwargs['callback'] = return_list
            dyn.append(path)
        options = []
        if 'options' in collected:
            options.extend(collected['options'])
        for key, values in collected.items():
            if key in ['options', 'properties']:
                continue
            option = make_optiondescriptions(key, values)
            if option is None:
                return
            options.append(option)
        if properties != []:
            kwargs['properties'] = tuple(properties)
        obj = optiondescription(path, "{}'s optiondescription".format(path), options, **kwargs)
        weakrefs.append(weakref.ref(obj))
        return obj
            
    collect_options = {}
    if require or consistency:
        noptions = OrderedDict()
        if require:
            noptions['extraoptrequire'] = {}
        if consistency:
            subpath = list(options.keys())[0]
            if '.' in subpath:
                subpath = subpath.rsplit('.', 1)[0] + '.'
            else:
                subpath = ''
            noptions[subpath + 'extraoptconsistency'] = {}
        noptions.update(options)
    else:
        noptions = options

    for path, option in noptions.items():
        if option is None:
            continue
        local_collect_options = collect_options
        for optiondescription in path.split('.')[:-1]:
            local_collect_options.setdefault(optiondescription, {'properties': {}})
            local_collect_options = local_collect_options[optiondescription]
            local_collect_options['properties'].update(option.get(optiondescription, {}))
        option_name = path.split('.')[-1]
        obj = make_option(option_name, option.get(option_name))
        goptions.append(obj)
        local_collect_options.setdefault('options', []).append(obj)

    rootod = make_optiondescriptions('root', collect_options)
    if rootod is None:
        return None, None
    cfg = Config(rootod, session_id='conftest')
    weakrefs.append(weakref.ref(cfg))
    if meta:
        cfg = MetaConfig([cfg], session_id='metatest')
        weakrefs.append(weakref.ref(cfg))
    del goptions
    return cfg, weakrefs, dyn


DICT_PATHS = [
    #test a config without optiondescription
    OrderedDict([('first', {}),
                 ('second', {'second': {'disabled': True}}),
                 ('third', {'third': {'hidden': True}})
                 ]),
    #test a config with an optiondescription
    OrderedDict([('subod.first', {}),
                 ('subod.second', {'second': {'disabled': True}}),
                 ('subod.third', {'third': {'hidden': True}})]),
    #test a config with two optiondescription
    OrderedDict([('subod.subsubod.first', {}),
                 ('subod.subsubod.second', {'second': {'disabled': True}}),
                 ('subod.subsubod.third', {'third': {'hidden': True}})]),
    #test a config with mix of different optiondescription
    OrderedDict([('first', {}),
                 ('subod.second', {'second': {'disabled': True}}),
                 ('subod.subsubod.third', {'third': {'hidden': True}})]),
    #test a config with masterslaves
    OrderedDict([('odmaster.first', {'master': {'master': True}}),
                 ('odmaster.second', {'second': {'disabled': True, 'slave': True}}),
                 ('odmaster.third', {'third': {'hidden': True, 'slave': True}})]),
    ##test a config with dynoption
    OrderedDict([('subod.first', {'subod': {'dyn': True}}),
                 ('subod.second', {'second': {'disabled': True}}),
                 ('subod.third', {'third': {'hidden': True}}),
                 ('subodval1.firstval1', None),
                 ('subodval1.secondval1', None),
                 ('subodval1.thirdval1', None),
                 ('subodval2.firstval2', None),
                 ('subodval2.secondval2', None),
                 ('subodval2.thirdval2', None)]),
    #test a config with dynoption subdir
    OrderedDict([('subod.subsubod.first', {'subsubod': {'dyn': True}}),
                 ('subod.subsubod.second', {'subsubod': {'dyn': True}, 'second': {'disabled': True}}),
                 ('subod.subsubod.third', {'subsubod': {'dyn': True}, 'third': {'hidden': True}}),
                 ('subod.subsubodval1.firstval1', None),
                 ('subod.subsubodval1.secondval1', None),
                 ('subod.subsubodval1.thirdval1', None),
                 ('subod.subsubodval2.firstval2', None),
                 ('subod.subsubodval2.secondval2', None),
                 ('subod.subsubodval2.thirdval2', None)]),
    #test a config with hidden subsubod
    OrderedDict([('subod.subsubod.first', {'subsubod': {'hidden': True}}),
                 ('subod.subsubod.second', {'subsubod': {'hidden': True}}),
                 ('subod.subsubod.third', {'subsubod': {'hidden': True}})]),
    #test a config with hidden dyn subsubod
    OrderedDict([('subod.subsubod.first', {'subsubod': {'dyn': True, 'hidden': True}}),
                 ('subod.subsubod.second', {'subsubod': {'dyn': True, 'hidden': True}}),
                 ('subod.subsubod.third', {'subsubod': {'dyn': True, 'hidden': True}}),
                 ('subod.subsubodval1.firstval1', None),
                 ('subod.subsubodval1.secondval1', None),
                 ('subod.subsubodval1.thirdval1', None),
                 ('subod.subsubodval2.firstval2', None),
                 ('subod.subsubodval2.secondval2', None),
                 ('subod.subsubodval2.thirdval2', None)])
]


@pytest.fixture(scope="function", params=DICT_PATHS)
def paths(request):
    if DISPLAY:
        print(u'\n{} {}: {}'.format(ICON, request.function.__name__, request.param))
    return request.param


def test_options(paths):
    def get_kwargs_option(options, kwargs, od=False):
        if options.get('hidden', False) is True:
            kwargs['permissive'] = True
            if not od:
                kwargs.setdefault('extra_properties', []).append('hidden')
            else:
                kwargs['permissive_od'] = True
        if options.get('disabled', False) is True:
            kwargs['propertyerror'] = True
            if not od:
                kwargs.setdefault('extra_properties', []).append('disabled')
            else:
                kwargs['propertyerror_od'] = True

    def get_kwargs(path):
        kwargs = {}
        spath = path.split('.')
        get_kwargs_option(paths[path].get(spath[-1], {}), kwargs)
        if len(spath) > 1:
            get_kwargs_option(paths[path].get(spath[-2], {}), kwargs, od=True)
        return kwargs

    lpaths = list(paths.keys())
    meta = False
    #for meta in (False, True):
    for consistency in (False, True):
        for require in (False, True):
            for default_multi in (False, True):
                for default in (False, True):
                    for multi in (False, True, submulti):
                        if multi is submulti and consistency:
                            continue
                        if multi is False and default_multi:
                            continue
                        cfg, weakrefs, dyn = make_conf(paths, meta, multi, default, default_multi, require, consistency)
                        if cfg is None:
                            continue
                        if dyn:
                            cnt = 0
                            idx = 0
                            for index, lpath in enumerate(lpaths):
                                if paths[lpath]:
                                    cnt += 1
                                else:
                                    check_all(cfg, lpaths[index], meta, multi, default,
                                              default_multi, require, consistency, **get_kwargs(lpaths[idx]))
                                    idx += 1
                                    if idx == cnt:
                                        idx = 0
                        else:
                            for lpath in lpaths:
                                check_all(cfg, lpath, meta, multi, default,
                                          default_multi, require, consistency, **get_kwargs(lpath))
                        del cfg
                        check_deref(weakrefs)