961 lines
41 KiB
Python
961 lines
41 KiB
Python
"""test API
|
|
"""
|
|
import pytest
|
|
from py.test import raises
|
|
import weakref
|
|
from .autopath import do_autopath
|
|
do_autopath()
|
|
from tiramisu import Config, StrOption, OptionDescription, MasterSlaves, DynOptionDescription, \
|
|
getapi
|
|
from tiramisu.error import PropertiesOptionError, APIError
|
|
from collections import OrderedDict
|
|
ICON = u'\u2937'
|
|
|
|
OPTIONS_TYPE = {'str': {'type': str,
|
|
'option': StrOption}
|
|
}
|
|
PROPERTIES = ['hidden', 'disabled']
|
|
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_owner_without_value(api, path, **kwargs):
|
|
"""check different value of owner when any value is set to this option
|
|
"""
|
|
try:
|
|
isslave = api.forcepermissive.option(path).option.isslave()
|
|
except:
|
|
isslave = False
|
|
# check if owner is a string "default"
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.option(path).owner.get() == 'default'
|
|
else:
|
|
assert api.option(path, 0).owner.get() == 'default'
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).owner.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).owner.get()")
|
|
raises(APIError, "api.unrestraint.option(path).owner.get()")
|
|
if not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.forcepermissive.option(path).owner.get() == 'default'
|
|
else:
|
|
assert api.forcepermissive.option(path, 0).owner.get() == 'default'
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.get()")
|
|
|
|
# check if default owner
|
|
raises(APIError, "api.unrestraint.option(path).owner.isdefault()")
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.option(path).owner.isdefault()
|
|
else:
|
|
assert api.option(path, 0).owner.isdefault()
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path).owner.isdefault()")
|
|
if not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.forcepermissive.option(path).owner.isdefault()
|
|
else:
|
|
assert api.forcepermissive.option(path, 0).owner.isdefault()
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.isdefault()")
|
|
|
|
|
|
@autocheck
|
|
def autocheck_value(api, path, **kwargs):
|
|
"""set and get values
|
|
"""
|
|
# check if is a multi, a master or a slave
|
|
if not kwargs.get('propertyerror', False):
|
|
multi = api.forcepermissive.option(path).option.ismulti()
|
|
ismaster = api.forcepermissive.option(path).option.ismaster()
|
|
isslave = api.forcepermissive.option(path).option.isslave()
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).option.ismulti()")
|
|
multi = api.unrestraint.option(path).option.ismulti()
|
|
ismaster = api.unrestraint.option(path).option.ismaster()
|
|
isslave = api.unrestraint.option(path).option.isslave()
|
|
|
|
# set default value (different if value is multi or not)
|
|
if not multi:
|
|
first_value = 'myvalue'
|
|
second_value = 'myvalue1'
|
|
else:
|
|
first_value = ['myvalue']
|
|
second_value = ['myvalue', 'myvalue1']
|
|
if multi and not isslave:
|
|
empty_value = []
|
|
else:
|
|
empty_value = None
|
|
|
|
# test default value (should be empty) without permissive
|
|
# cannot test for slave (we cannot get all values for a slave)
|
|
if not isslave:
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
assert api.option(path).value.get() == empty_value
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
|
|
# test default value (should be empty) with permissive
|
|
# cannot test for slave (we cannot get all values for a slave)
|
|
raises(APIError, "api.unrestraint.option(path).value.get()")
|
|
if not isslave:
|
|
if not kwargs.get('propertyerror', False):
|
|
assert api.forcepermissive.option(path).value.get() == empty_value
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()")
|
|
|
|
# set a value without permissive
|
|
# for slave should have an index and good length
|
|
# for master must append, not set
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if ismaster:
|
|
raises(APIError, "api.option(path, 0).value.set(first_value[0])")
|
|
api.option(path).value.set([first_value[0]])
|
|
elif isslave:
|
|
api.option(path, 0).value.set(first_value[0])
|
|
else:
|
|
api.option(path).value.set(first_value)
|
|
else:
|
|
if ismaster:
|
|
raises(PropertiesOptionError, "api.option(path).value.set([first_value[0]])")
|
|
elif isslave:
|
|
raises(PropertiesOptionError, "api.option(path, 0).value.set(first_value[0])")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path).value.set(first_value)")
|
|
|
|
# get value after set value without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if isslave:
|
|
assert api.option(path, 0).value.get() == first_value[0]
|
|
else:
|
|
assert api.option(path).value.get() == first_value
|
|
elif kwargs.get('permissive', False):
|
|
if isslave:
|
|
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
|
|
assert api.forcepermissive.option(path, 0).value.get() == empty_value
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
assert api.forcepermissive.option(path).value.get() == empty_value
|
|
else:
|
|
if isslave:
|
|
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()")
|
|
|
|
# set a value with permissive
|
|
if ismaster:
|
|
raises(APIError, "api.unrestraint.option(path).value.set(second_value[1])")
|
|
elif isslave:
|
|
raises(APIError, "api.unrestraint.option(path).value.set([first_value[0], second_value[1]])")
|
|
else:
|
|
raises(APIError, "api.unrestraint.option(path).value.set(second_value)")
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if ismaster:
|
|
raises(APIError, "api.forcepermissive.option(path, 1).value.set(second_value[1])")
|
|
api.forcepermissive.option(path).value.set([first_value[0], second_value[1]])
|
|
elif isslave:
|
|
#FIXME
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.set([first_value[0], second_value[1]])")
|
|
api.option(path, 1).value.set(second_value[1])
|
|
raise Exception('ca entre ici')
|
|
else:
|
|
api.option(path).value.set(second_value)
|
|
elif kwargs.get('permissive', False):
|
|
if ismaster:
|
|
api.forcepermissive.option(path).value.set([first_value[0], second_value[1]])
|
|
elif isslave:
|
|
api.forcepermissive.option(path, 1).value.set(second_value[1])
|
|
else:
|
|
api.forcepermissive.option(path).value.set(first_value)
|
|
else:
|
|
if ismaster:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.set([first_value[0]])")
|
|
elif isslave:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.set(first_value[0])")
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.set(first_value)")
|
|
|
|
# get value after set value with permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if isslave:
|
|
assert api.option(path, 0).value.get() == second_value[0]
|
|
assert api.option(path, 1).value.get() == second_value[1]
|
|
else:
|
|
assert api.option(path).value.get() == second_value
|
|
elif kwargs.get('permissive', False):
|
|
if ismaster:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
assert api.forcepermissive.option(path).value.get() == second_value
|
|
elif isslave:
|
|
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
|
|
raises(PropertiesOptionError, "api.option(path, 1).value.get()")
|
|
assert api.forcepermissive.option(path, 1).value.get() == second_value[1]
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
assert api.forcepermissive.option(path).value.get() == first_value
|
|
else:
|
|
if isslave:
|
|
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()")
|
|
|
|
|
|
@autocheck
|
|
def autocheck_reset_value(api, path, **kwargs):
|
|
# check if is a multi, a master or a slave
|
|
multi = api.unrestraint.option(path).option.ismulti()
|
|
isslave = api.unrestraint.option(path).option.isslave()
|
|
|
|
# set default value (different if value is multi or not)
|
|
if not multi:
|
|
first_value = 'myvalue'
|
|
second_value = 'myvalue1'
|
|
else:
|
|
first_value = ['myvalue']
|
|
second_value = ['myvalue', 'myvalue1']
|
|
if multi and not isslave:
|
|
empty_value = []
|
|
else:
|
|
empty_value = None
|
|
|
|
# reset value without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
api.option(path).value.reset()
|
|
else:
|
|
api.option(path, 0).value.reset()
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).value.reset()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).value.reset()")
|
|
|
|
# get value after reset value without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if isslave:
|
|
assert api.option(path, 0).value.get() == empty_value
|
|
assert api.option(path, 1).value.get() == second_value[1]
|
|
else:
|
|
assert api.option(path).value.get() == empty_value
|
|
elif kwargs.get('permissive', False):
|
|
if isslave:
|
|
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:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
assert api.forcepermissive.option(path).value.get() == first_value
|
|
|
|
# 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()")
|
|
|
|
# get value after reset value with permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if isslave:
|
|
assert api.option(path, 0).value.get() == empty_value
|
|
assert api.option(path, 1).value.get() == empty_value
|
|
else:
|
|
assert api.option(path).value.get() == empty_value
|
|
elif kwargs.get('permissive', False):
|
|
if isslave:
|
|
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
|
|
raises(PropertiesOptionError, "api.option(path, 1).value.get()")
|
|
assert api.forcepermissive.option(path, 0).value.get() == empty_value
|
|
assert api.forcepermissive.option(path, 1).value.get() == empty_value
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
assert api.forcepermissive.option(path).value.get() == empty_value
|
|
|
|
|
|
@autocheck
|
|
def autocheck_value2(*args, **kwargs):
|
|
"""re set value
|
|
"""
|
|
autocheck_value(*args, **kwargs)
|
|
|
|
|
|
@autocheck
|
|
def autocheck_display(api, path, **kwargs):
|
|
"""re set value
|
|
"""
|
|
#FIXME utile ?
|
|
print(api.config)
|
|
|
|
|
|
@autocheck
|
|
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()
|
|
|
|
# define properties
|
|
properties = ['prop1', 'prop2']
|
|
if multi and not isslave:
|
|
default_props = ['empty']
|
|
properties.append('empty')
|
|
else:
|
|
default_props = []
|
|
extra_properties = kwargs.get('extra_properties')
|
|
if extra_properties:
|
|
properties.extend(extra_properties)
|
|
default_props.extend(extra_properties)
|
|
properties = tuple(properties)
|
|
|
|
# get properties without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert set(api.option(path).property.get()) == set(default_props)
|
|
else:
|
|
assert set(api.option(path, 0).property.get()) == set(default_props)
|
|
assert set(api.option(path, 1).property.get()) == set(default_props)
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).property.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).property.get()")
|
|
|
|
# get properties with permissive
|
|
if not isslave:
|
|
raises(APIError, "api.unrestraint.option(path).property.get()")
|
|
else:
|
|
raises(APIError, "api.unrestraint.option(path, 0).property.get()")
|
|
if not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(default_props)
|
|
else:
|
|
assert set(api.forcepermissive.option(path, 0).property.get()) == set(default_props)
|
|
assert set(api.forcepermissive.option(path, 1).property.get()) == set(default_props)
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).property.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).property.get()")
|
|
|
|
# set properties without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
api.option(path).property.set(properties)
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).property.set(properties)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).property.set(properties)")
|
|
|
|
# check properties after set without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
assert set(api.option(path).property.get()) == set(properties)
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(properties)
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).property.get()")
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(default_props)
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).property.get()")
|
|
assert set(api.forcepermissive.option(path, 0).property.get()) == set(default_props)
|
|
assert set(api.forcepermissive.option(path, 1).property.get()) == set(default_props)
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).property.get()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).property.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).property.get()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).property.get()")
|
|
|
|
# set properties with permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
api.forcepermissive.option(path).property.set(properties)
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).property.set(properties)")
|
|
|
|
# check properties after set with permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert set(api.option(path).property.get()) == set(properties)
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(properties)
|
|
else:
|
|
assert set(api.option(path, 0).property.get()) == set(properties)
|
|
assert set(api.forcepermissive.option(path, 0).property.get()) == set(properties)
|
|
assert set(api.option(path, 1).property.get()) == set(properties)
|
|
assert set(api.forcepermissive.option(path, 1).property.get()) == set(properties)
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).property.get()")
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(properties)
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).property.get()")
|
|
assert set(api.forcepermissive.option(path, 0).property.get()) == set(properties)
|
|
raises(PropertiesOptionError, "api.option(path, 1).property.get()")
|
|
assert set(api.forcepermissive.option(path, 1).property.get()) == set(properties)
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).property.get()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).property.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).property.get()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).property.get()")
|
|
|
|
|
|
@autocheck
|
|
def autocheck_reset_property(api, path, **kwargs):
|
|
"""check properties after set with permissive
|
|
"""
|
|
|
|
# check if is a multi or a slave
|
|
if not kwargs.get('propertyerror', False):
|
|
multi = api.forcepermissive.option(path).option.ismulti()
|
|
isslave = api.forcepermissive.option(path).option.isslave()
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).option.ismulti()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).option.isslave()")
|
|
multi = api.unrestraint.option(path).option.ismulti()
|
|
isslave = api.unrestraint.option(path).option.isslave()
|
|
|
|
# define properties
|
|
properties = ['prop1', 'prop2']
|
|
if multi and not isslave:
|
|
default_props = ['empty']
|
|
properties.append('empty')
|
|
else:
|
|
default_props = []
|
|
extra_properties = kwargs.get('extra_properties')
|
|
if extra_properties:
|
|
properties.extend(extra_properties)
|
|
default_props.extend(extra_properties)
|
|
properties = tuple(properties)
|
|
|
|
# check properties
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
assert set(api.option(path).property.get()) == set(properties)
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(properties)
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(properties)
|
|
else:
|
|
assert set(api.forcepermissive.option(path, 0).property.get()) == set(properties)
|
|
assert set(api.forcepermissive.option(path, 1).property.get()) == set(properties)
|
|
|
|
# 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 properties
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert set(api.option(path).property.get()) == set(default_props)
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(default_props)
|
|
else:
|
|
assert set(api.option(path, 0).property.get()) == set(default_props)
|
|
assert set(api.forcepermissive.option(path, 0).property.get()) == set(default_props)
|
|
assert set(api.option(path, 1).property.get()) == set(default_props)
|
|
assert set(api.forcepermissive.option(path, 1).property.get()) == set(default_props)
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(properties)
|
|
else:
|
|
assert set(api.forcepermissive.option(path, 0).property.get()) == set(properties)
|
|
assert set(api.forcepermissive.option(path, 1).property.get()) == set(properties)
|
|
|
|
# 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 properties
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert set(api.option(path).property.get()) == set(default_props)
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(default_props)
|
|
else:
|
|
assert set(api.option(path, 0).property.get()) == set(default_props)
|
|
assert set(api.forcepermissive.option(path, 0).property.get()) == set(default_props)
|
|
assert set(api.option(path, 1).property.get()) == set(default_props)
|
|
assert set(api.forcepermissive.option(path, 1).property.get()) == set(default_props)
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
assert set(api.forcepermissive.option(path).property.get()) == set(default_props)
|
|
else:
|
|
assert set(api.forcepermissive.option(path, 0).property.get()) == set(default_props)
|
|
assert set(api.forcepermissive.option(path, 1).property.get()) == set(default_props)
|
|
|
|
|
|
@autocheck
|
|
def autocheck_property2(*args, **kwargs):
|
|
return autocheck_property(*args, display=False, **kwargs)
|
|
|
|
|
|
@autocheck
|
|
def autocheck_owner_with_value(api, path, **kwargs):
|
|
"""value is now changed, check owner in this case
|
|
"""
|
|
# check if is a isslave
|
|
if not kwargs.get('propertyerror', False):
|
|
isslave = api.forcepermissive.option(path).option.isslave()
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).option.isslave()")
|
|
isslave = api.unrestraint.option(path).option.isslave()
|
|
|
|
# get owner without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.option(path).owner.get() == 'user'
|
|
else:
|
|
assert api.option(path, 0).owner.get() == 'user'
|
|
assert api.option(path, 1).owner.get() == 'user'
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).owner.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).owner.get()")
|
|
raises(PropertiesOptionError, "api.option(path, 1).owner.get()")
|
|
|
|
# get owner with permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.forcepermissive.option(path).owner.get() == 'user'
|
|
else:
|
|
assert api.forcepermissive.option(path, 0).owner.get() == 'default'
|
|
assert api.forcepermissive.option(path, 1).owner.get() == 'user'
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).owner.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).owner.get()")
|
|
|
|
# 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()")
|
|
|
|
# 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(api, path, **kwargs):
|
|
# test set owner without permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
isslave = api.forcepermissive.option(path).option.isslave()
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).option.isslave()")
|
|
isslave = False
|
|
|
|
# set owner without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
api.option(path).owner.set('new_user')
|
|
else:
|
|
api.option(path, 1).owner.set('new_user')
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).owner.set('new_user')")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 1).owner.set('new_user')")
|
|
|
|
# check owner set without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.option(path).owner.get() == 'new_user'
|
|
assert api.forcepermissive.option(path).owner.get() == 'new_user'
|
|
else:
|
|
assert api.option(path, 1).owner.get() == 'new_user'
|
|
assert api.forcepermissive.option(path, 1).owner.get() == 'new_user'
|
|
elif not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.forcepermissive.option(path).owner.get() == 'user'
|
|
else:
|
|
assert api.forcepermissive.option(path, 1).owner.get() == 'user'
|
|
|
|
# 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')")
|
|
|
|
# get owner set with permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.forcepermissive.option(path).owner.get() == 'new_user1'
|
|
else:
|
|
assert api.forcepermissive.option(path, 0).owner.get() == 'default'
|
|
assert api.forcepermissive.option(path, 1).owner.get() == 'new_user1'
|
|
|
|
|
|
@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
|
|
"""
|
|
# check if is a multi, a master or a slave
|
|
if not kwargs.get('propertyerror', False):
|
|
multi = api.forcepermissive.option(path).option.ismulti()
|
|
ismaster = api.forcepermissive.option(path).option.ismaster()
|
|
isslave = api.forcepermissive.option(path).option.isslave()
|
|
else:
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).option.ismulti()")
|
|
multi = api.unrestraint.option(path).option.ismulti()
|
|
ismaster = api.unrestraint.option(path).option.ismaster()
|
|
isslave = api.unrestraint.option(path).option.isslave()
|
|
|
|
# set default value (different if value is multi or not)
|
|
if not multi:
|
|
first_value = 'myvalue'
|
|
second_value = 'myvalue1'
|
|
else:
|
|
first_value = ['myvalue']
|
|
second_value = ['myvalue', 'myvalue1']
|
|
if multi and not isslave:
|
|
empty_value = []
|
|
else:
|
|
empty_value = None
|
|
|
|
# cannot access to hidden value without forcepermissive
|
|
# and to disabled value (with forcepermissive too)
|
|
if kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path).value.get()")
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
|
|
raises(PropertiesOptionError, "api.forcepermissive.option(path, 0).value.get()")
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
api.forcepermissive.option(path).value.get()
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
|
|
api.forcepermissive.option(path, 0).value.get()
|
|
else:
|
|
if not isslave:
|
|
api.option(path).value.get()
|
|
else:
|
|
api.option(path, 0).value.get()
|
|
assert api.unrestraint.option(path).permissive.get() == frozenset()
|
|
api.unrestraint.option(path).permissive.set(('disabled',))
|
|
assert api.unrestraint.option(path).permissive.get() == frozenset(['disabled'])
|
|
|
|
|
|
# can access to disabled value
|
|
if kwargs.get('permissive', False):
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.option(path).value.get()")
|
|
api.forcepermissive.option(path).value.get()
|
|
else:
|
|
raises(PropertiesOptionError, "api.option(path, 0).value.get()")
|
|
api.forcepermissive.option(path, 0).value.get()
|
|
else:
|
|
if not isslave:
|
|
api.option(path).value.get()
|
|
else:
|
|
api.option(path, 0).value.get()
|
|
|
|
#FIXME
|
|
#api.option(path).permissive.set(('disabled', 'hidden'))
|
|
|
|
## can access to value
|
|
#if not isslave:
|
|
# api.option(path).value.get()
|
|
#else:
|
|
# api.option(path, 0).value.get()
|
|
#assert api.option(path).permissive.get() == frozenset(['disabled', 'hidden'])
|
|
#
|
|
#print('FIXME del !!!')
|
|
|
|
|
|
|
|
def check_all(api, path, multi, **kwargs):
|
|
if DISPLAY:
|
|
text = u' {} launch tests for {}'.format(ICON, path)
|
|
if multi:
|
|
text += u' as a multi'
|
|
text += u', kwargs: {}'.format(kwargs)
|
|
print(text)
|
|
for func in autocheck_registers:
|
|
if DISPLAY:
|
|
print(u' {} {}'.format(ICON, func.__name__))
|
|
func(api, path, **kwargs)
|
|
|
|
|
|
def make_api(options, multi):
|
|
weakrefs = []
|
|
def make_option(path, option_infos):
|
|
#FIXME
|
|
option_type = 'str'
|
|
option_properties = []
|
|
if option_infos is not None:
|
|
for prop in PROPERTIES:
|
|
if option_infos.get(prop, False) is True:
|
|
option_properties.append(prop)
|
|
args = [path, "{}'s option".format(path)]
|
|
kwargs = {}
|
|
if option_properties != []:
|
|
kwargs['properties'] = tuple(option_properties)
|
|
if multi:
|
|
kwargs['multi'] = True
|
|
tiramisu_option = OPTIONS_TYPE[option_type]['option']
|
|
obj = tiramisu_option(*args, **kwargs)
|
|
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
|
|
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 = {}
|
|
for path, option in options.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]
|
|
path = '.'.join(path.split('.')[:-1])
|
|
local_collect_options.setdefault('options', []).append(make_option(option_name, option.get(option_name)))
|
|
|
|
rootod = make_optiondescriptions('root', collect_options)
|
|
if rootod is None:
|
|
return None, None
|
|
cfg = Config(rootod, session_id='conftest')
|
|
weakrefs.append(weakref.ref(cfg))
|
|
api = getapi(cfg)
|
|
weakrefs.append(weakref.ref(api))
|
|
return api, weakrefs
|
|
|
|
|
|
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', {'odmaster': {'master': True}}),
|
|
('odmaster.second', {'second': {'disabled': True}}),
|
|
('odmaster.third', {'third': {'hidden': 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')
|
|
if options.get('disabled', False) is True:
|
|
kwargs['propertyerror'] = True
|
|
if not od:
|
|
kwargs.setdefault('extra_properties', []).append('disabled')
|
|
|
|
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())
|
|
for multi in (False, True):
|
|
api, weakrefs = make_api(paths, multi)
|
|
if api is None:
|
|
continue
|
|
if len(lpaths) == 9:
|
|
check_all(api, lpaths[3], multi, **get_kwargs(lpaths[0]))
|
|
check_all(api, lpaths[4], multi, **get_kwargs(lpaths[1]))
|
|
check_all(api, lpaths[5], multi, **get_kwargs(lpaths[2]))
|
|
check_all(api, lpaths[6], multi, **get_kwargs(lpaths[0]))
|
|
check_all(api, lpaths[7], multi, **get_kwargs(lpaths[1]))
|
|
check_all(api, lpaths[8], multi, **get_kwargs(lpaths[2]))
|
|
else:
|
|
check_all(api, lpaths[0], multi, **get_kwargs(lpaths[0]))
|
|
check_all(api, lpaths[1], multi, **get_kwargs(lpaths[1]))
|
|
check_all(api, lpaths[2], multi, **get_kwargs(lpaths[2]))
|
|
del(api)
|
|
for wr in weakrefs:
|
|
assert wr() is None
|