821 lines
32 KiB
Python
821 lines
32 KiB
Python
"""test API to get/set owner
|
|
"""
|
|
import pytest
|
|
from py.test import raises
|
|
from .autopath import do_autopath
|
|
do_autopath()
|
|
from tiramisu import Config, StrOption, OptionDescription, MasterSlaves, DynOptionDescription, \
|
|
getapi
|
|
from tiramisu.error import PropertiesOptionError
|
|
ICON = u'\u2937'
|
|
|
|
OPTIONS_TYPE = {'str': {'type': str,
|
|
'option': StrOption}
|
|
}
|
|
PROPERTIES = ['hidden', 'disabled']
|
|
|
|
|
|
def return_list(val=None, suffix=None):
|
|
if val:
|
|
return val
|
|
else:
|
|
return ['val1', 'val2']
|
|
|
|
|
|
def display_info(func):
|
|
def wrapper(*args, **kwargs):
|
|
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 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.permissive.option.isslave(path)
|
|
except:
|
|
isslave = False
|
|
# check if owner is a string "default"
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
assert api.owner.get(path) == 'default'
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.owner.get(path)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.owner.get(path, 0)")
|
|
if not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.permissive.owner.get(path) == 'default'
|
|
else:
|
|
assert api.permissive.owner.get(path, 0) == 'default'
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.permissive.owner.get(path)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.owner.get(path, 0)")
|
|
|
|
# check if default owner
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
assert api.owner.isdefault(path)
|
|
else:
|
|
raises(PropertiesOptionError, "api.owner.isdefault(path)")
|
|
if not kwargs.get('propertyerror', False):
|
|
assert api.permissive.owner.isdefault(path)
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.owner.isdefault(path)")
|
|
|
|
|
|
@autocheck
|
|
def autocheck_value(api, path, **kwargs):
|
|
"""set and get values
|
|
"""
|
|
print('=============')
|
|
try:
|
|
print(api.permissive.owner.get(path))
|
|
except Exception as pouet:
|
|
try:
|
|
print(api.permissive.owner.get(path, 0))
|
|
except Exception as pouet:
|
|
print(pouet)
|
|
pass
|
|
# check if is a multi, a master or a slave
|
|
if not kwargs.get('propertyerror', False):
|
|
multi = api.permissive.option.ismulti(path)
|
|
ismaster = api.permissive.option.ismaster(path)
|
|
isslave = api.permissive.option.isslave(path)
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.option.ismulti(path)")
|
|
multi = False
|
|
ismaster = False
|
|
isslave = False
|
|
|
|
# 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.value.get(path) == empty_value
|
|
else:
|
|
raises(PropertiesOptionError, "api.value.get(path)")
|
|
|
|
# test default value (should be empty) with permissive
|
|
# cannot test for slave (we cannot get all values for a slave)
|
|
if not isslave:
|
|
if not kwargs.get('propertyerror', False):
|
|
assert api.permissive.value.get(path) == empty_value
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.value.get(path)")
|
|
|
|
# set a value without permissive
|
|
# for master/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(IndexError, "api.value.set(path, 0, first_value[0])")
|
|
api.value.append(path, first_value[0])
|
|
elif isslave:
|
|
#FIXME
|
|
print(api.value.append(path, first_value[0]))
|
|
raises(PropertiesOptionError, "api.value.append(path, first_value[0])")
|
|
api.value.set(path, 0, first_value[0])
|
|
raise Exception('pouet')
|
|
else:
|
|
api.value.set(path, first_value)
|
|
else:
|
|
if ismaster:
|
|
raises(PropertiesOptionError, "api.value.append(path, first_value[0])")
|
|
elif isslave:
|
|
raises(PropertiesOptionError, "api.value.set(path, 0, first_value[0])")
|
|
else:
|
|
raises(PropertiesOptionError, "api.value.set(path, 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.value.get(path, 0) == first_value[0]
|
|
else:
|
|
assert api.value.get(path) == first_value
|
|
elif kwargs.get('permissive', False):
|
|
if isslave:
|
|
raises(PropertiesOptionError, "api.value.get(path, 0)")
|
|
assert api.permissive.value.get(path, 0) == empty_value
|
|
else:
|
|
raises(PropertiesOptionError, "api.value.get(path)")
|
|
assert api.permissive.value.get(path) == empty_value
|
|
else:
|
|
if isslave:
|
|
raises(PropertiesOptionError, "api.value.get(path, 0)")
|
|
raises(PropertiesOptionError, "api.permissive.value.get(path, 0)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.value.get(path)")
|
|
raises(PropertiesOptionError, "api.permissive.value.get(path)")
|
|
|
|
# set a value with permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if ismaster:
|
|
raises(IndexError, "api.permissive.value.set(path, 1, second_value[1])")
|
|
api.permissive.value.append(path, second_value[1])
|
|
elif isslave:
|
|
#FIXME
|
|
raises(PropertiesOptionError, "api.permissive.value.append(path, second_value[1])")
|
|
api.value.set(path, 1, second_value[1])
|
|
raise Exception('ca entre ici')
|
|
else:
|
|
api.value.set(path, second_value)
|
|
elif kwargs.get('permissive', False):
|
|
if ismaster:
|
|
api.permissive.value.append(path, second_value[0])
|
|
api.permissive.value.append(path, second_value[1])
|
|
elif isslave:
|
|
api.permissive.value.set(path, 1, second_value[1])
|
|
else:
|
|
api.permissive.value.set(path, first_value)
|
|
else:
|
|
if ismaster:
|
|
raises(PropertiesOptionError, "api.permissive.value.append(path, first_value[0])")
|
|
elif isslave:
|
|
raises(PropertiesOptionError, "api.permissive.value.set(path, 0, first_value[0])")
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.value.set(path, 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.value.get(path, 0) == second_value[0]
|
|
assert api.value.get(path, 1) == second_value[1]
|
|
else:
|
|
assert api.value.get(path) == second_value
|
|
elif kwargs.get('permissive', False):
|
|
if ismaster:
|
|
raises(PropertiesOptionError, "api.value.get(path)")
|
|
assert api.permissive.value.get(path) == second_value
|
|
elif isslave:
|
|
raises(PropertiesOptionError, "api.value.get(path, 0)")
|
|
raises(PropertiesOptionError, "api.value.get(path, 1)")
|
|
assert api.permissive.value.get(path, 1) == second_value[1]
|
|
else:
|
|
raises(PropertiesOptionError, "api.value.get(path)")
|
|
assert api.permissive.value.get(path) == first_value
|
|
else:
|
|
if isslave:
|
|
raises(PropertiesOptionError, "api.value.get(path, 0)")
|
|
raises(PropertiesOptionError, "api.permissive.value.get(path, 0)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.value.get(path)")
|
|
raises(PropertiesOptionError, "api.permissive.value.get(path)")
|
|
print('=============')
|
|
try:
|
|
print(api.permissive.owner.get(path))
|
|
except Exception as pouet:
|
|
try:
|
|
print(api.permissive.owner.get(path, 0))
|
|
except Exception as pouet:
|
|
print(pouet)
|
|
pass
|
|
|
|
|
|
@autocheck
|
|
def autocheck_reset_value(api, path, **kwargs):
|
|
# check if is a multi, a master or a slave
|
|
if not kwargs.get('propertyerror', False):
|
|
multi = api.permissive.option.ismulti(path)
|
|
ismaster = api.permissive.option.ismaster(path)
|
|
isslave = api.permissive.option.isslave(path)
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.option.ismulti(path)")
|
|
multi = False
|
|
ismaster = False
|
|
isslave = False
|
|
|
|
# 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.value.reset(path)
|
|
else:
|
|
api.value.reset(path, 0)
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.value.reset(path)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.value.reset(path, 0)")
|
|
|
|
# get value after reset value without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if isslave:
|
|
assert api.value.get(path, 0) == empty_value
|
|
assert api.value.get(path, 1) == second_value[1]
|
|
else:
|
|
assert api.value.get(path) == empty_value
|
|
elif kwargs.get('permissive', False):
|
|
if isslave:
|
|
raises(PropertiesOptionError, "api.value.get(path, 0)")
|
|
assert api.permissive.value.get(path, 0) == empty_value
|
|
assert api.permissive.value.get(path, 1) == second_value[1]
|
|
else:
|
|
raises(PropertiesOptionError, "api.value.get(path)")
|
|
assert api.permissive.value.get(path) == first_value
|
|
|
|
# reset value with permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
api.permissive.value.reset(path)
|
|
else:
|
|
api.permissive.value.reset(path, 1)
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
api.permissive.value.reset(path)
|
|
else:
|
|
api.permissive.value.reset(path, 1)
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.permissive.value.reset(path)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.value.reset(path, 1)")
|
|
|
|
# get value after reset value with permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if isslave:
|
|
assert api.value.get(path, 0) == empty_value
|
|
assert api.value.get(path, 1) == empty_value
|
|
else:
|
|
assert api.value.get(path) == empty_value
|
|
elif kwargs.get('permissive', False):
|
|
if isslave:
|
|
raises(PropertiesOptionError, "api.value.get(path, 0)")
|
|
raises(PropertiesOptionError, "api.value.get(path, 1)")
|
|
assert api.permissive.value.get(path, 0) == empty_value
|
|
assert api.permissive.value.get(path, 1) == empty_value
|
|
else:
|
|
raises(PropertiesOptionError, "api.value.get(path)")
|
|
assert api.permissive.value.get(path) == empty_value
|
|
|
|
|
|
@autocheck
|
|
def autocheck_value2(*args, **kwargs):
|
|
"""reset value
|
|
"""
|
|
autocheck_value(*args, **kwargs)
|
|
|
|
|
|
@autocheck
|
|
def autocheck_property(api, path, **kwargs):
|
|
"""get property from path
|
|
"""
|
|
# check if is a multi or a slave
|
|
if not kwargs.get('propertyerror', False):
|
|
multi = api.permissive.option.ismulti(path)
|
|
isslave = api.permissive.option.isslave(path)
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.option.ismulti(path)")
|
|
raises(PropertiesOptionError, "api.permissive.option.isslave(path)")
|
|
multi = False
|
|
isslave = False
|
|
|
|
# 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.property.get(path)) == set(default_props)
|
|
else:
|
|
assert set(api.property.get(path, 0)) == set(default_props)
|
|
assert set(api.property.get(path, 1)) == set(default_props)
|
|
else:
|
|
raises(PropertiesOptionError, "api.property.get(path)")
|
|
|
|
# get properties with permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert set(api.permissive.property.get(path)) == set(default_props)
|
|
else:
|
|
assert set(api.permissive.property.get(path, 0)) == set(default_props)
|
|
assert set(api.permissive.property.get(path, 1)) == set(default_props)
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.permissive.property.get(path)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.property.get(path, 0)")
|
|
|
|
# set properties without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
api.property.set(path, properties)
|
|
else:
|
|
raises(PropertiesOptionError, "api.property.set(path, properties)")
|
|
|
|
# check properties after set without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
assert set(api.property.get(path)) == set(properties)
|
|
assert set(api.permissive.property.get(path)) == set(properties)
|
|
elif kwargs.get('permissive', False):
|
|
raises(PropertiesOptionError, "api.property.get(path)")
|
|
if not isslave:
|
|
assert set(api.permissive.property.get(path)) == set(default_props)
|
|
else:
|
|
assert set(api.permissive.property.get(path, 0)) == set(default_props)
|
|
assert set(api.permissive.property.get(path, 1)) == set(default_props)
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.property.get(path)")
|
|
raises(PropertiesOptionError, "api.permissive.property.get(path)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.property.get(path, 0)")
|
|
raises(PropertiesOptionError, "api.permissive.property.get(path, 0)")
|
|
|
|
# set properties with permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
api.permissive.property.set(path, properties)
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.property.set(path, 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.property.get(path)) == set(properties)
|
|
assert set(api.permissive.property.get(path)) == set(properties)
|
|
else:
|
|
assert set(api.property.get(path, 0)) == set(properties)
|
|
assert set(api.permissive.property.get(path, 0)) == set(properties)
|
|
assert set(api.property.get(path, 1)) == set(properties)
|
|
assert set(api.permissive.property.get(path, 1)) == set(properties)
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.property.get(path)")
|
|
assert set(api.permissive.property.get(path)) == set(properties)
|
|
else:
|
|
raises(PropertiesOptionError, "api.property.get(path, 0)")
|
|
assert set(api.permissive.property.get(path, 0)) == set(properties)
|
|
raises(PropertiesOptionError, "api.property.get(path, 1)")
|
|
assert set(api.permissive.property.get(path, 1)) == set(properties)
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.property.get(path)")
|
|
raises(PropertiesOptionError, "api.permissive.property.get(path)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.property.get(path, 0)")
|
|
raises(PropertiesOptionError, "api.permissive.property.get(path, 0)")
|
|
|
|
|
|
@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.permissive.option.ismulti(path)
|
|
isslave = api.permissive.option.isslave(path)
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.option.ismulti(path)")
|
|
raises(PropertiesOptionError, "api.permissive.option.isslave(path)")
|
|
multi = False
|
|
isslave = False
|
|
|
|
# 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.property.get(path)) == set(properties)
|
|
assert set(api.permissive.property.get(path)) == set(properties)
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
assert set(api.permissive.property.get(path)) == set(properties)
|
|
else:
|
|
assert set(api.permissive.property.get(path, 0)) == set(properties)
|
|
assert set(api.permissive.property.get(path, 1)) == set(properties)
|
|
|
|
# reset properties without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
api.property.reset(path)
|
|
else:
|
|
raises(PropertiesOptionError, "api.property.reset(path)")
|
|
|
|
# check properties
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert set(api.property.get(path)) == set(default_props)
|
|
assert set(api.permissive.property.get(path)) == set(default_props)
|
|
else:
|
|
assert set(api.property.get(path, 0)) == set(default_props)
|
|
assert set(api.permissive.property.get(path, 0)) == set(default_props)
|
|
assert set(api.property.get(path, 1)) == set(default_props)
|
|
assert set(api.permissive.property.get(path, 1)) == set(default_props)
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
assert set(api.permissive.property.get(path)) == set(properties)
|
|
else:
|
|
assert set(api.permissive.property.get(path, 0)) == set(properties)
|
|
assert set(api.permissive.property.get(path, 1)) == set(properties)
|
|
|
|
# reset properties with permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
api.permissive.property.set(path, properties)
|
|
api.permissive.property.reset(path)
|
|
elif kwargs.get('permissive', False):
|
|
api.permissive.property.reset(path)
|
|
|
|
# check properties
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert set(api.property.get(path)) == set(default_props)
|
|
assert set(api.permissive.property.get(path)) == set(default_props)
|
|
else:
|
|
assert set(api.property.get(path, 0)) == set(default_props)
|
|
assert set(api.permissive.property.get(path, 0)) == set(default_props)
|
|
assert set(api.property.get(path, 1)) == set(default_props)
|
|
assert set(api.permissive.property.get(path, 1)) == set(default_props)
|
|
elif kwargs.get('permissive', False):
|
|
if not isslave:
|
|
assert set(api.permissive.property.get(path)) == set(default_props)
|
|
else:
|
|
assert set(api.permissive.property.get(path, 0)) == set(default_props)
|
|
assert set(api.permissive.property.get(path, 1)) == 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.permissive.option.isslave(path)
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.option.isslave(path)")
|
|
isslave = False
|
|
|
|
# get owner without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.owner.get(path) == 'user'
|
|
else:
|
|
assert api.owner.get(path, 0) == 'user'
|
|
assert api.owner.get(path, 1) == 'user'
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.owner.get(path)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.owner.get(path, 0)")
|
|
raises(PropertiesOptionError, "api.owner.get(path, 1)")
|
|
|
|
# get owner with permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.permissive.owner.get(path) == 'user'
|
|
else:
|
|
print('--------')
|
|
print(api.permissive.owner.get(path, 0))
|
|
print(api.permissive.value.get(path, 0))
|
|
assert api.permissive.owner.get(path, 0) == 'default'
|
|
assert api.permissive.owner.get(path, 1) == 'user'
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.permissive.owner.get(path)")
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.owner.get(path, 0)")
|
|
|
|
# test if is default owner without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
assert api.owner.isdefault(path) is False
|
|
else:
|
|
raises(PropertiesOptionError, "api.owner.isdefault(path)")
|
|
|
|
# test if is default owner with permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
assert api.permissive.owner.isdefault(path) is False
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.owner.isdefault(path)")
|
|
|
|
|
|
@autocheck
|
|
def autocheck_set_owner(api, path, **kwargs):
|
|
# test set owner without permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
isslave = api.permissive.option.isslave(path)
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.option.isslave(path)")
|
|
isslave = False
|
|
|
|
# set owner without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
api.owner.set(path, 'new_user')
|
|
else:
|
|
api.owner.set(path, 1, 'new_user')
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.owner.set(path, 'new_user')")
|
|
else:
|
|
raises(PropertiesOptionError, "api.owner.set(path, 1, 'new_user')")
|
|
|
|
# check owner set without permissive
|
|
if not kwargs.get('permissive', False) and not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.owner.get(path) == 'new_user'
|
|
assert api.permissive.owner.get(path) == 'new_user'
|
|
else:
|
|
assert api.owner.get(path, 1) == 'new_user'
|
|
assert api.permissive.owner.get(path, 1) == 'new_user'
|
|
elif not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.permissive.owner.get(path) == 'user'
|
|
else:
|
|
assert api.permissive.owner.get(path, 1) == 'user'
|
|
|
|
# set owner with permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
api.permissive.owner.set(path, 'new_user1')
|
|
else:
|
|
api.permissive.owner.set(path, 1, 'new_user1')
|
|
else:
|
|
if not isslave:
|
|
raises(PropertiesOptionError, "api.permissive.owner.set(path, 'new_user1')")
|
|
else:
|
|
raises(PropertiesOptionError, "api.permissive.owner.set(path, 1, 'new_user1')")
|
|
|
|
# get owner set with permissive
|
|
if not kwargs.get('propertyerror', False):
|
|
if not isslave:
|
|
assert api.permissive.owner.get(path) == 'new_user1'
|
|
else:
|
|
assert api.permissive.owner.get(path, 0) == 'default'
|
|
assert api.permissive.owner.get(path, 1) == 'new_user1'
|
|
|
|
|
|
def check_all(api, path, multi, **kwargs):
|
|
text = u' {} launch tests for {}'.format(ICON, path)
|
|
if multi:
|
|
text += u' as a multi'
|
|
print(text)
|
|
for func in autocheck_registers:
|
|
print(u' {} {}'.format(ICON, func.__name__))
|
|
func(api, path, **kwargs)
|
|
|
|
|
|
def make_api(options, multi):
|
|
def make_option(path):
|
|
option_infos = path.split('_')
|
|
option_type = 'str'
|
|
option_properties = []
|
|
for option_info in option_infos[1:]:
|
|
if option_info in OPTIONS_TYPE:
|
|
option_type = option_info
|
|
elif option_info in PROPERTIES:
|
|
option_properties.append(option_info)
|
|
else:
|
|
raise Exception('unknown {} in {}'.format(option_info, path))
|
|
args = [option_infos[0], "{}'s option".format(option_infos[0])]
|
|
kwargs = {}
|
|
if option_properties != []:
|
|
kwargs['properties'] = tuple(option_properties)
|
|
if multi:
|
|
kwargs['multi'] = True
|
|
tiramisu_option = OPTIONS_TYPE[option_type]['option']
|
|
return tiramisu_option(*args, **kwargs)
|
|
|
|
def make_optiondescriptions(path, collected):
|
|
infos = path.split('_')
|
|
name = infos[0]
|
|
properties = []
|
|
kwargs = {}
|
|
optiondescription = OptionDescription
|
|
for info in infos[1:]:
|
|
if info in PROPERTIES:
|
|
properties.append(info)
|
|
elif info == 'master':
|
|
if not multi:
|
|
return
|
|
optiondescription = MasterSlaves
|
|
elif info == 'dyn':
|
|
optiondescription = DynOptionDescription
|
|
kwargs['callback'] = return_list
|
|
else:
|
|
raise Exception('unknown {} in {}'.format(info, path))
|
|
options = []
|
|
if 'options' in collected:
|
|
options.extend(collected['options'])
|
|
for key, values in collected.items():
|
|
if key == 'options':
|
|
continue
|
|
option = make_optiondescriptions(key, values)
|
|
if option is None:
|
|
return
|
|
options.append(option)
|
|
if properties != []:
|
|
kwargs['properties'] = tuple(properties)
|
|
return optiondescription(name, "{}'s optiondescription".format(name), options, **kwargs)
|
|
|
|
collect_options = {}
|
|
for option in options:
|
|
if option is None:
|
|
continue
|
|
local_collect_options = collect_options
|
|
for optiondescription in option.split('.')[:-1]:
|
|
local_collect_options.setdefault(optiondescription, {})
|
|
local_collect_options = local_collect_options[optiondescription]
|
|
path = '.'.join(option.split('.')[:-1])
|
|
option_name = option.split('.')[-1]
|
|
local_collect_options.setdefault("options", []).append(make_option(option_name))
|
|
|
|
rootod = make_optiondescriptions('root', collect_options)
|
|
if rootod is None:
|
|
return
|
|
cfg = Config(rootod)
|
|
return getapi(cfg)
|
|
|
|
|
|
DICT_PATHS = [
|
|
#test a config without optiondescription
|
|
{'first': 'first',
|
|
'second': 'second_disabled',
|
|
'third': 'third_hidden'},
|
|
#test a config with an optiondescription
|
|
{'subod.first': 'subod.first',
|
|
'subod.second': 'subod.second_disabled',
|
|
'subod.third': 'subod.third_hidden'},
|
|
#test a config with two optiondescription
|
|
{'subod.subsubod.first': 'subod.subsubod.first',
|
|
'subod.subsubod.second': 'subod.subsubod.second_disabled',
|
|
'subod.subsubod.third': 'subod.subsubod.third_hidden'},
|
|
#test a config with mix of different optiondescription
|
|
{'first': 'first',
|
|
'subod.second': 'subod.second_disabled',
|
|
'subod.subsubod.third': 'subod.subsubod.third_hidden'},
|
|
#test a config with masterslaves
|
|
{'first.first': 'first_master.first',
|
|
'first.second': 'first_master.second_disabled',
|
|
'first.third': 'first_master.third_hidden'},
|
|
##test a config with dynoption
|
|
{'subodval1.firstval1': 'subod_dyn.first',
|
|
'subodval1.secondval1': 'subod_dyn.second_disabled',
|
|
'subodval1.thirdval1': 'subod_dyn.third_hidden',
|
|
'subodval2.firstval2': None,
|
|
'subodval2.secondval2': None,
|
|
'subodval2.thirdval2': None},
|
|
#test a config with dynoption subdir
|
|
{'subod.subodval1.firstval1': 'subod.subod_dyn.first',
|
|
'subod.subodval1.secondval1': 'subod.subod_dyn.second_disabled',
|
|
'subod.subodval1.thirdval1': 'subod.subod_dyn.third_hidden',
|
|
'subod.subodval2.firstval2': None,
|
|
'subod.subodval2.secondval2': None,
|
|
'subod.subodval2.thirdval2': None}
|
|
]
|
|
|
|
|
|
@pytest.fixture(scope="function", params=DICT_PATHS)
|
|
def paths(request):
|
|
print(u'\n{} {}: {}'.format(ICON, request.function.__name__, request.param))
|
|
return request.param
|
|
|
|
|
|
def test_options(paths):
|
|
lpaths = list(paths.keys())
|
|
for multi in (False, True):
|
|
api = make_api(paths.values(), multi)
|
|
if api is None:
|
|
continue
|
|
check_all(api, lpaths[0], multi)
|
|
check_all(api, lpaths[1], multi, propertyerror=True, extra_properties=['disabled'])
|
|
check_all(api, lpaths[2], multi, permissive=True, extra_properties=['hidden'])
|
|
if len(lpaths) == 6:
|
|
check_all(api, lpaths[3], multi)
|
|
check_all(api, lpaths[4], multi, propertyerror=True, extra_properties=['disabled'])
|
|
check_all(api, lpaths[5], multi, permissive=True, extra_properties=['hidden'])
|
|
##
|
|
#print('')
|
|
#print(api.help)
|
|
|
|
|
|
@display_info
|
|
def test_tree_od_permissive():
|
|
"""permissive when optiondescription is hidden
|
|
"""
|
|
tpaths = [
|
|
{'subod.subsubod.first': 'subod.subsubod_hidden.first',
|
|
'subod.subsubod.second': 'subod.subsubod_hidden.second',
|
|
'subod.subsubod.third': 'subod.subsubod_hidden.third_hidden'},
|
|
{'subod.subodval1.firstval1': 'subod.subod_dyn_hidden.first',
|
|
'subod.subodval1.secondval1': 'subod.subod_dyn_hidden.second',
|
|
'subod.subodval1.thirdval1': 'subod.subod_dyn_hidden.third_hidden',
|
|
'subod.subodval2.firstval2': None,
|
|
'subod.subodval2.secondval2': None,
|
|
'subod.subodval2.thirdval2': None
|
|
}
|
|
]
|
|
for paths in tpaths:
|
|
lpaths = list(paths.keys())
|
|
for multi in (False, True):
|
|
api = make_api(paths.values(), multi)
|
|
if api is None:
|
|
continue
|
|
check_all(api, lpaths[0], multi, permissive=True)
|
|
check_all(api, lpaths[1], multi, permissive=True)
|
|
check_all(api, lpaths[2], multi, permissive=True, extra_properties=['hidden'])
|
|
if len(lpaths) == 6:
|
|
check_all(api, lpaths[3], multi, permissive=True)
|
|
check_all(api, lpaths[4], multi, permissive=True)
|
|
check_all(api, lpaths[5], multi, permissive=True, extra_properties=['hidden'])
|