3291 lines
164 KiB
Python
3291 lines
164 KiB
Python
# coding: utf-8
|
|
from .autopath import do_autopath
|
|
do_autopath()
|
|
from .config import config_type, get_config
|
|
|
|
from copy import copy
|
|
from tiramisu.i18n import _
|
|
from tiramisu.setting import groups
|
|
from tiramisu import setting
|
|
setting.expires_time = 1
|
|
from tiramisu import IPOption, OptionDescription, BoolOption, IntOption, StrOption, \
|
|
Leadership, Config, calc_value, Params, ParamOption, Calculation, ParamValue, ParamSelfOption, ParamIndex, \
|
|
calc_value_property_help
|
|
from tiramisu.error import PropertiesOptionError, RequirementError, ConfigError, display_list
|
|
from py.test import raises
|
|
from tiramisu.storage import list_sessions, delete_session
|
|
|
|
|
|
def teardown_function(function):
|
|
assert list_sessions() == [], 'session list is not empty when leaving "{}"'.format(function.__name__)
|
|
|
|
|
|
def test_properties(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = IPOption('ip_address_service', '', properties=('disabled',))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg_ori = Config(od)
|
|
cfg_ori.property.read_write()
|
|
cfg = get_config(cfg_ori, config_type)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
if config_type == 'tiramisu-api':
|
|
cfg.send()
|
|
cfg_ori.unrestraint.option('ip_address_service').property.pop('disabled')
|
|
cfg = get_config(cfg_ori, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
if config_type == 'tiramisu-api':
|
|
cfg.send()
|
|
cfg_ori.unrestraint.option('ip_address_service').property.add('disabled')
|
|
cfg = get_config(cfg_ori, config_type)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
# pop twice
|
|
if config_type == 'tiramisu-api':
|
|
cfg.send()
|
|
cfg_ori.unrestraint.option('ip_address_service').property.pop('disabled')
|
|
cfg_ori.unrestraint.option('ip_address_service').property.pop('disabled')
|
|
|
|
|
|
def test_requires_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
assert not cfg.option('activate_service').option.requires()
|
|
assert cfg.option('ip_address_service').option.requires()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('activate_service').value.set(True)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_requires(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, todict=True),
|
|
'expected': ParamValue(False)}))
|
|
b = IPOption('ip_address_service', '',
|
|
properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
assert not cfg.option('activate_service').option.requires()
|
|
assert not cfg.option('ip_address_service').option.requires()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('activate_service').value.set(True)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_requires_callback_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'callback': calc_value, 'callback_params': Params(ParamOption(a)), 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
assert not cfg.option('activate_service').option.requires()
|
|
assert cfg.option('ip_address_service').option.requires()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('activate_service').value.set(True)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_requires_inverse_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': False, 'action': 'disabled', 'inverse': True}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('activate_service').value.set(False)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set(True)
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_inverse(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, todict=True),
|
|
'expected': ParamValue(False),
|
|
'inverse_condition': ParamValue(True)}))
|
|
b = IPOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('activate_service').value.set(False)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set(True)
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_self_legacy(config_type):
|
|
a = StrOption('ip_address_service', '',
|
|
requires=[{'option': 'self', 'expected': 'b', 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.option('ip_address_service').value.get() == None
|
|
cfg.option('ip_address_service').value.set('a')
|
|
assert cfg.option('ip_address_service').value.get() == 'a'
|
|
cfg.option('ip_address_service').value.set('b')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_self(config_type):
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamSelfOption(),
|
|
'expected': ParamValue('b')}))
|
|
a = StrOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.option('ip_address_service').value.get() == None
|
|
cfg.option('ip_address_service').value.set('a')
|
|
assert cfg.option('ip_address_service').value.get() == 'a'
|
|
cfg.option('ip_address_service').value.set('b')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_with_requires_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg.option('ip_address_service').property.add('test')
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('activate_service').value.set(True)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_requires_with_requires(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a),
|
|
'expected': ParamValue(False)}))
|
|
b = IPOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg.option('ip_address_service').property.add('test')
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('activate_service').value.set(True)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_requires_invalid_legacy():
|
|
a = BoolOption('activate_service', '', True)
|
|
a
|
|
raises(ValueError, "IPOption('ip_address_service', '', requires='string')")
|
|
raises(ValueError, "IPOption('ip_address_service', '', requires=[{'option': a, 'expected': False, 'action': 'disabled', 'unknown': True}])")
|
|
raises(ValueError, "IPOption('ip_address_service', '', requires=[{'option': a, 'expected': False}])")
|
|
raises(ValueError, "IPOption('ip_address_service', '', requires=[{'option': a, 'action': 'disabled'}])")
|
|
raises(ValueError, "IPOption('ip_address_service', '', requires=[{'expected': False, 'action': 'disabled'}])")
|
|
raises(ValueError, "IPOption('ip_address_service', '', requires=[{'option': a, 'expected': False, 'action': 'disabled', 'inverse': 'string'}])")
|
|
raises(ValueError, "IPOption('ip_address_service', '', requires=[{'option': a, 'expected': False, 'action': 'disabled', 'transitive': 'string'}])")
|
|
raises(ValueError, "IPOption('ip_address_service', '', requires=[{'option': a, 'expected': False, 'action': 'disabled', 'same_action': 'string'}])")
|
|
raises(ValueError, "IPOption('ip_address_service', '', requires=[{'option': 'string', 'expected': False, 'action': 'disabled'}])")
|
|
raises(ValueError, "IPOption('ip_address_service', '', requires=[{'option': a, 'expected': 'string', 'action': 'disabled'}])")
|
|
|
|
|
|
def test_requires_same_action_legacy(config_type):
|
|
activate_service = BoolOption('activate_service', '', True)
|
|
activate_service_web = BoolOption('activate_service_web', '', True,
|
|
requires=[{'option': activate_service, 'expected': False,
|
|
'action': 'new'}])
|
|
|
|
ip_address_service_web = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': activate_service_web, 'expected': False,
|
|
'action': 'disabled', 'inverse': False,
|
|
'transitive': True, 'same_action': False}])
|
|
od1 = OptionDescription('service', '', [activate_service, activate_service_web, ip_address_service_web])
|
|
cfg = Config(od1)
|
|
cfg.property.read_write()
|
|
cfg.property.add('new')
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert frozenset(props) == frozenset(['new'])
|
|
else:
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
submsg = '"disabled" (' + _('the value of "{0}" is {1}').format('activate_service', '"False"') + ')'
|
|
if config_type == 'tiramisu':
|
|
assert str(err) == str(_('cannot access to {0} "{1}" because has {2} {3}').format('option', 'ip_address_service_web', _('property'), submsg))
|
|
#access to cache
|
|
assert str(err) == str(_('cannot access to {0} "{1}" because has {2} {3}').format('option', 'ip_address_service_web', _('property'), submsg))
|
|
else:
|
|
# FIXME
|
|
assert str(err) == 'error'
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_same_action(config_type):
|
|
activate_service = BoolOption('activate_service', '', True)
|
|
new_property = Calculation(calc_value,
|
|
Params(ParamValue('new'),
|
|
kwargs={'condition': ParamOption(activate_service, todict=True),
|
|
'expected': ParamValue(False)}),
|
|
calc_value_property_help)
|
|
activate_service_web = BoolOption('activate_service_web', '', True, properties=(new_property,))
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(activate_service_web, notraisepropertyerror=True, todict=True),
|
|
'expected': ParamValue(False)}),
|
|
calc_value_property_help)
|
|
ip_address_service_web = IPOption('ip_address_service_web', '', properties=(disabled_property,))
|
|
od1 = OptionDescription('service', '', [activate_service, activate_service_web, ip_address_service_web])
|
|
cfg = Config(od1)
|
|
cfg.property.read_write()
|
|
cfg.property.add('new')
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert frozenset(props) == frozenset(['new'])
|
|
else:
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
submsg = '"disabled" (' + _('the value of "{0}" is {1}').format('activate_service', '"False"') + ')'
|
|
if config_type == 'tiramisu':
|
|
submsg = '"new" (' + _('the value of "{0}" is {1}').format('activate_service', '"False"') + ')'
|
|
submsg = '"disabled" (' + str(_('cannot access to {0} "{1}" because has {2} {3}').format('option', 'activate_service_web', _('property'), submsg)) + ')'
|
|
assert str(err) == str(_('cannot access to {0} "{1}" because has {2} {3}').format('option', 'ip_address_service_web', _('property'), submsg))
|
|
#access to cache
|
|
assert str(err) == str(_('cannot access to {0} "{1}" because has {2} {3}').format('option', 'ip_address_service_web', _('property'), submsg))
|
|
else:
|
|
# FIXME
|
|
assert str(err) == 'error'
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_same_action_callback_legacy(config_type):
|
|
activate_service = BoolOption('activate_service', '', True)
|
|
activate_service_web = BoolOption('activate_service_web', '', True,
|
|
requires=[{'callback': calc_value, 'callback_params': Params(ParamOption(activate_service)), 'expected': False,
|
|
'action': 'new'}])
|
|
|
|
ip_address_service_web = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': activate_service_web, 'expected': False,
|
|
'action': 'disabled', 'inverse': False,
|
|
'transitive': True, 'same_action': False}])
|
|
od1 = OptionDescription('service', '', [activate_service, activate_service_web, ip_address_service_web])
|
|
cfg = Config(od1)
|
|
cfg.property.read_write()
|
|
cfg.property.add('new')
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert frozenset(props) == frozenset(['new'])
|
|
else:
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
submsg = '"disabled" (' + _('the calculated value is {0}').format('"False"') + ')'
|
|
if config_type == 'tiramisu':
|
|
assert str(err) == str(_('cannot access to {0} "{1}" because has {2} {3}').format('option', 'ip_address_service_web', _('property'), submsg))
|
|
#access to cache
|
|
assert str(err) == str(_('cannot access to {0} "{1}" because has {2} {3}').format('option', 'ip_address_service_web', _('property'), submsg))
|
|
else:
|
|
# FIXME
|
|
assert str(err) == 'error'
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_multiple_requires_legacy(config_type):
|
|
a = StrOption('activate_service', '')
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': 'yes', 'action': 'disabled'},
|
|
{'option': a, 'expected': 'ok', 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set('yes')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set('ok')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set('no')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_multiple_requires(config_type):
|
|
a = StrOption('activate_service', '')
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a),
|
|
'expected_0': ParamValue('yes'),
|
|
'expected_1': ParamValue('ok')}))
|
|
b = IPOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set('yes')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set('ok')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set('no')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_multiple_requires_cumulative_legacy(config_type):
|
|
a = StrOption('activate_service', '')
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': 'yes', 'action': 'disabled'},
|
|
{'option': a, 'expected': 'yes', 'action': 'hidden'}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set('yes')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert set(props) == {'hidden', 'disabled'}
|
|
else:
|
|
assert set(props) == {'disabled'}
|
|
|
|
cfg.option('activate_service').value.set('ok')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set('no')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_multiple_requires_cumulative(config_type):
|
|
a = StrOption('activate_service', '')
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a),
|
|
'expected': ParamValue('yes')}))
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition': ParamOption(a),
|
|
'expected': ParamValue('yes')}))
|
|
b = IPOption('ip_address_service', '', properties=(disabled_property, hidden_property))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
cfg.option('activate_service').value.set('yes')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert set(props) == {'hidden', 'disabled'}
|
|
else:
|
|
assert set(props) == {'disabled'}
|
|
|
|
cfg.option('activate_service').value.set('ok')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set('no')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_multiple_requires_cumulative_inverse_legacy(config_type):
|
|
a = StrOption('activate_service', '')
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': 'yes', 'action': 'disabled', 'inverse': True},
|
|
{'option': a, 'expected': 'yes', 'action': 'hidden', 'inverse': True}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert set(props) == {'hidden', 'disabled'}
|
|
else:
|
|
assert set(props) == {'disabled'}
|
|
cfg.option('activate_service').value.set('yes')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set('ok')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert set(props) == {'hidden', 'disabled'}
|
|
else:
|
|
assert set(props) == {'disabled'}
|
|
|
|
cfg.option('activate_service').value.set('no')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert set(props) == {'hidden', 'disabled'}
|
|
else:
|
|
assert set(props) == {'disabled'}
|
|
|
|
|
|
def test_multiple_requires_cumulative_inverse(config_type):
|
|
a = StrOption('activate_service', '')
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a),
|
|
'expected': ParamValue('yes'),
|
|
'inverse_condition': ParamValue(True)}))
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition': ParamOption(a),
|
|
'expected': ParamValue('yes'),
|
|
'inverse_condition': ParamValue(True)}))
|
|
b = IPOption('ip_address_service', '', properties=(disabled_property, hidden_property))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert set(props) == {'hidden', 'disabled'}
|
|
else:
|
|
assert set(props) == {'disabled'}
|
|
cfg.option('activate_service').value.set('yes')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set('ok')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert set(props) == {'hidden', 'disabled'}
|
|
else:
|
|
assert set(props) == {'disabled'}
|
|
|
|
cfg.option('activate_service').value.set('no')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu':
|
|
assert set(props) == {'hidden', 'disabled'}
|
|
else:
|
|
assert set(props) == {'disabled'}
|
|
|
|
|
|
def test_multiple_requires_inverse_legacy(config_type):
|
|
a = StrOption('activate_service', '')
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': 'yes', 'action': 'disabled', 'inverse': True},
|
|
{'option': a, 'expected': 'ok', 'action': 'disabled', 'inverse': True}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set('yes')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set('ok')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set('no')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_multiple_requires_inverse(config_type):
|
|
a = StrOption('activate_service', '')
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a),
|
|
'expected_0': ParamValue('yes'),
|
|
'expected_1': ParamValue('ok'),
|
|
'inverse_condition': ParamValue(True)}))
|
|
b = IPOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set('yes')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set('ok')
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set('no')
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_transitive_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('activate_service_web', '', True,
|
|
requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
|
|
d = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': b, 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_transitive(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
b = BoolOption('activate_service_web', '', True, properties=(disabled_property,))
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(b, raisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
|
|
d = IPOption('ip_address_service_web', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_transitive_callback_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('activate_service_web', '', True,
|
|
requires=[{'callback': calc_value, 'callback_params': Params(ParamOption(a)), 'expected': False, 'action': 'disabled'}])
|
|
|
|
d = IPOption('ip_address_service_web', '',
|
|
requires=[{'callback': calc_value, 'callback_params': Params(ParamOption(b)), 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_transitive_unrestraint_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('activate_service_web', '', True,
|
|
requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
|
|
d = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': b, 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg_ori = Config(od)
|
|
cfg_ori.property.read_write()
|
|
cfg = get_config(cfg_ori, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
if config_type == 'tiramisu-api':
|
|
cfg.send()
|
|
assert cfg_ori.unrestraint.option('activate_service_web').property.get() == {'disabled'}
|
|
assert cfg_ori.unrestraint.option('ip_address_service_web').property.get() == {'disabled'}
|
|
|
|
|
|
def test_requires_transitive_unrestraint(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
b = BoolOption('activate_service_web', '', True, properties=(disabled_property,))
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(b, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
d = IPOption('ip_address_service_web', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg_ori = Config(od)
|
|
cfg_ori.property.read_write()
|
|
cfg = get_config(cfg_ori, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
if config_type == 'tiramisu-api':
|
|
cfg.send()
|
|
assert cfg_ori.unrestraint.option('activate_service_web').property.get() == {'disabled'}
|
|
assert cfg_ori.unrestraint.option('ip_address_service_web').property.get() == {'disabled'}
|
|
|
|
|
|
def test_requires_transitive_owner_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('activate_service_web', '', True,
|
|
requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
|
|
d = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': b, 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
#no more default value
|
|
cfg.option('ip_address_service_web').value.set('1.1.1.1')
|
|
cfg.option('activate_service').value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_transitive_owner(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
b = BoolOption('activate_service_web', '', True, properties=(disabled_property,))
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(b, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
|
|
d = IPOption('ip_address_service_web', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
#no more default value
|
|
cfg.option('ip_address_service_web').value.set('1.1.1.1')
|
|
cfg.option('activate_service').value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_transitive_bis_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
abis = BoolOption('activate_service_bis', '', True)
|
|
b = BoolOption('activate_service_web', '', True,
|
|
requires=[{'option': a, 'expected': True, 'action': 'disabled', 'inverse': True}])
|
|
|
|
d = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': b, 'expected': True, 'action': 'disabled', 'inverse': True}])
|
|
od = OptionDescription('service', '', [a, abis, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
#
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_transitive_bis(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
abis = BoolOption('activate_service_bis', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(True),
|
|
'inverse_condition': ParamValue(True)}))
|
|
b = BoolOption('activate_service_web', '', True, properties=(disabled_property,))
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(b, notraisepropertyerror=True),
|
|
'expected': ParamValue(True),
|
|
'inverse_condition': ParamValue(True)}))
|
|
d = IPOption('ip_address_service_web', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, abis, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
#
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_transitive_hidden_permissive_legacy():
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('activate_service_web', '', True,
|
|
requires=[{'option': a, 'expected': False, 'action': 'hidden'}])
|
|
d = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': b, 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
# FIXME permissive cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
cfg.option('ip_address_service_web').value.get()
|
|
|
|
|
|
def test_requires_transitive_hidden_permissive():
|
|
a = BoolOption('activate_service', '', True)
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
b = BoolOption('activate_service_web', '', True, properties=(hidden_property,))
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(b, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
d = IPOption('ip_address_service_web', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
# FIXME permissive cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
cfg.option('ip_address_service_web').value.get()
|
|
|
|
|
|
def test_requires_transitive_hidden_disabled_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('activate_service_web', '', True,
|
|
requires=[{'option': a, 'expected': False, 'action': 'hidden'}])
|
|
d = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': b, 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu-api':
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
else:
|
|
assert frozenset(props) == frozenset(['hidden'])
|
|
cfg.option('ip_address_service_web').value.get()
|
|
|
|
|
|
def test_requires_transitive_hidden_disabled(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
b = BoolOption('activate_service_web', '', True, properties=(hidden_property,))
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(b, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
d = IPOption('ip_address_service_web', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu-api':
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
else:
|
|
assert frozenset(props) == frozenset(['hidden'])
|
|
cfg.option('ip_address_service_web').value.get()
|
|
|
|
|
|
def test_requires_transitive_hidden_disabled_multiple_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('activate_service_web', '', True,
|
|
requires=[{'option': a, 'expected': False, 'action': 'hidden'},
|
|
{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
d = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': b, 'expected': False, 'action': 'mandatory'}])
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg_ori = Config(od)
|
|
cfg_ori.property.read_write()
|
|
cfg = get_config(cfg_ori, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
req = None
|
|
if config_type == 'tiramisu-api':
|
|
try:
|
|
cfg.option('activate_service').value.set(False)
|
|
except ConfigError as err:
|
|
req = err
|
|
error_msg = str(_('unable to transform tiramisu object to dict: {}').format(_('cannot access to option "{0}" because required option "{1}" has {2} {3}').format('ip_address_service_web', 'activate_service_web', _('property'), '"disabled"')))
|
|
else:
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu-api':
|
|
assert set(props) == {'disabled',}
|
|
else:
|
|
assert set(props) == {'disabled', 'hidden'}
|
|
del props
|
|
#
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except RequirementError as err:
|
|
req = err
|
|
error_msg = str(_('cannot access to option "{0}" because required option "{1}" has {2} {3}').format('ip_address_service_web', 'activate_service_web', _('property'), '"disabled"'))
|
|
assert req, "ip_address_service_web should raise RequirementError"
|
|
assert str(req) == error_msg
|
|
del req
|
|
#
|
|
cfg_ori.permissive.set(frozenset())
|
|
if config_type == 'tiramisu-api':
|
|
try:
|
|
cfg = get_config(cfg_ori, config_type)
|
|
except ConfigError as err:
|
|
req = err
|
|
error_msg = str(_('unable to transform tiramisu object to dict: {}').format(_('cannot access to option "{0}" because required option "{1}" has {2} {3}').format('ip_address_service_web', 'activate_service_web', _('properties'), '"disabled" {} "hidden"'.format(_('and')))))
|
|
else:
|
|
cfg = get_config(cfg_ori, config_type)
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except RequirementError as err:
|
|
req = err
|
|
error_msg = str(_('cannot access to option "{0}" because required option "{1}" has {2} {3}').format('ip_address_service_web', 'activate_service_web', _('properties'), '"disabled" {} "hidden"'.format(_('and'))))
|
|
assert req, "ip_address_service_web should raise RequirementError"
|
|
assert str(req) == error_msg
|
|
del req
|
|
|
|
|
|
def test_requires_transitive_hidden_disabled_multiple(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
b = BoolOption('activate_service_web', '', True, properties=(hidden_property, disabled_property))
|
|
mandatory_property = Calculation(calc_value,
|
|
Params(ParamValue('mandatory'),
|
|
kwargs={'condition': ParamOption(b),
|
|
'expected': ParamValue(False)}))
|
|
d = IPOption('ip_address_service_web', '', properties=(mandatory_property,))
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg_ori = Config(od)
|
|
cfg_ori.property.read_write()
|
|
cfg = get_config(cfg_ori, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
req = None
|
|
if config_type == 'tiramisu-api':
|
|
try:
|
|
cfg.option('activate_service').value.set(False)
|
|
except ConfigError as err:
|
|
req = err
|
|
error_msg = str(_('unable to transform tiramisu object to dict: {}').format(_('cannot access to option "{0}" because required option "{1}" has {2} {3}').format('ip_address_service_web', 'activate_service_web', _('property'), '"disabled"')))
|
|
else:
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu-api':
|
|
assert set(props) == {'disabled',}
|
|
else:
|
|
assert set(props) == {'disabled', 'hidden'}
|
|
del props
|
|
#
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except ConfigError as err:
|
|
req = err
|
|
error_msg = str(_('unable to carry out a calculation for "{0}", cannot access to option "{1}" because has {2} {3}').format('ip_address_service_web', 'activate_service_web', _('properties'), display_list(['hidden', 'disabled'], add_quote=True)))
|
|
assert req, "ip_address_service_web should raise ConfigError"
|
|
assert str(req) == error_msg
|
|
del req
|
|
#
|
|
cfg_ori.permissive.set(frozenset())
|
|
if config_type == 'tiramisu-api':
|
|
try:
|
|
cfg = get_config(cfg_ori, config_type)
|
|
except ConfigError as err:
|
|
req = err
|
|
error_msg = str(_('unable to transform tiramisu object to dict: {}').format(_('cannot access to option "{0}" because required option "{1}" has {2} {3}').format('ip_address_service_web', 'activate_service_web', _('properties'), '"disabled" {} "hidden"'.format(_('and')))))
|
|
else:
|
|
cfg = get_config(cfg_ori, config_type)
|
|
try:
|
|
cfg.option('ip_address_service_web').value.get()
|
|
except ConfigError as err:
|
|
req = err
|
|
error_msg = str(_('unable to carry out a calculation for "{0}", cannot access to option "{1}" because has {2} {3}').format('ip_address_service_web', 'activate_service_web', _('properties'), display_list(['hidden', 'disabled'], add_quote=True)))
|
|
assert req, "ip_address_service_web should raise RequirementError"
|
|
assert str(req) == error_msg
|
|
del req
|
|
|
|
|
|
def test_requires_not_transitive_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('activate_service_web', '', True,
|
|
requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
d = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': b, 'expected': False,
|
|
'action': 'disabled', 'transitive': False}])
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
cfg.option('ip_address_service_web').value.get()
|
|
|
|
|
|
def test_requires_not_transitive(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
b = BoolOption('activate_service_web', '', True, properties=(disabled_property,))
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(b, notraisepropertyerror=True),
|
|
'no_condition_is_invalid': ParamValue(True),
|
|
'expected': ParamValue(False)}))
|
|
d = IPOption('ip_address_service_web', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
cfg.option('ip_address_service_web').value.get()
|
|
|
|
|
|
def test_requires_not_transitive_not_same_action_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('activate_service_web', '', True,
|
|
requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
d = IPOption('ip_address_service_web', '',
|
|
requires=[{'option': b, 'expected': False,
|
|
'action': 'hidden', 'transitive': False}])
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
if config_type == 'tiramisu-api':
|
|
raises(ConfigError, "cfg.option('activate_service').value.set(False)")
|
|
else:
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
raises(RequirementError, "cfg.option('ip_address_service_web').value.get()")
|
|
|
|
|
|
def test_requires_not_transitive_not_same_action(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
b = BoolOption('activate_service_web', '', True, properties=(disabled_property,))
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition': ParamOption(b),
|
|
'expected': ParamValue(False)}))
|
|
d = IPOption('ip_address_service_web', '', properties=(hidden_property,))
|
|
od = OptionDescription('service', '', [a, b, d])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('activate_service').value.get()
|
|
cfg.option('activate_service_web').value.get()
|
|
cfg.option('ip_address_service_web').value.get()
|
|
if config_type == 'tiramisu-api':
|
|
raises(ConfigError, "cfg.option('activate_service').value.set(False)")
|
|
else:
|
|
cfg.option('activate_service').value.set(False)
|
|
#
|
|
props = []
|
|
try:
|
|
cfg.option('activate_service_web').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
#
|
|
raises(ConfigError, "cfg.option('ip_address_service_web').value.get()")
|
|
|
|
|
|
def test_requires_none_legacy(config_type):
|
|
a = BoolOption('activate_service', '')
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': None, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('activate_service').value.set(False)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_requires_none(config_type):
|
|
a = BoolOption('activate_service', '')
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(None)}))
|
|
b = IPOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('activate_service').value.set(False)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_requires_multi_disabled_legacy(config_type):
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
c = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': True, 'action': 'disabled'},
|
|
{'option': b, 'expected': 1, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b, c])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(False)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('num_service').value.set(1)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_multi_disabled(config_type):
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition_0': ParamOption(a, notraisepropertyerror=True),
|
|
'condition_1': ParamOption(b, notraisepropertyerror=True),
|
|
'expected_0': ParamValue(True),
|
|
'expected_1': ParamValue(1),
|
|
'condition_operator': ParamValue('OR')}))
|
|
c = IPOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b, c])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(False)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('num_service').value.set(1)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_multi_disabled_callback_legacy(config_type):
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
c = IPOption('ip_address_service', '',
|
|
requires=[{'callback': calc_value, 'callback_params': Params(ParamOption(a)), 'expected': True, 'action': 'disabled'},
|
|
{'callback': calc_value, 'callback_params': Params(ParamOption(b)), 'expected': 1, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b, c])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(False)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('num_service').value.set(1)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_multi_disabled_new_format_legacy(config_type):
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
c = IPOption('ip_address_service', '',
|
|
requires=[{'expected': [{'option': a, 'value': True}, {'option': b, 'value': 1}], 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b, c])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(False)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('num_service').value.set(1)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_unknown_operator_legacy():
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
raises(ValueError, """IPOption('ip_address_service', '',
|
|
requires=[{'expected': [{'option': a, 'value': True}, {'option': b, 'value': 1}],
|
|
'action': 'disabled', 'operator': 'unknown'}])""")
|
|
|
|
|
|
def test_requires_keys_legacy():
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
raises(ValueError, """IPOption('ip_address_service', '',
|
|
requires=[{'expected': [{'option': a, 'value2': True}, {'option': b, 'value': 1}],
|
|
'action': 'disabled', 'operator': 'and'}])""")
|
|
|
|
|
|
def test_requires_unvalid_legacy():
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
raises(ValueError, """IPOption('ip_address_service', '',
|
|
requires=[{'expected': [{'option': a, 'value': 'unvalid'}, {'option': b, 'value': 1}],
|
|
'action': 'disabled', 'operator': 'and'}])""")
|
|
|
|
|
|
def test_requires_multi_disabled_new_format_and_legacy(config_type):
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
c = IPOption('ip_address_service', '',
|
|
requires=[{'expected': [{'option': a, 'value': True}, {'option': b, 'value': 1}], 'action': 'disabled', 'operator': 'and'}])
|
|
od = OptionDescription('service', '', [a, b, c])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert props == []
|
|
|
|
cfg.option('activate_service').value.set(False)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('num_service').value.set(1)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert props == []
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_multi_disabled_new_format_and_2_legacy(config_type):
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
c = IPOption('ip_address_service', '',
|
|
requires=[{'expected': [{'option': a, 'value': True}, {'option': b, 'value': 1}], 'action': 'disabled', 'operator': 'and'},
|
|
{'expected': [{'option': a, 'value': False}, {'option': b, 'value': 1}], 'action': 'expert'}])
|
|
od = OptionDescription('service', '', [a, b, c])
|
|
cfg = Config(od)
|
|
cfg.property.add('expert')
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert props == []
|
|
|
|
cfg.option('activate_service').value.set(False)
|
|
cfg.option('num_service').value.set(1)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu-api':
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
else:
|
|
assert frozenset(props) == frozenset(['expert'])
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
if config_type == 'tiramisu-api':
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
else:
|
|
assert frozenset(props) == frozenset(['disabled', 'expert'])
|
|
|
|
|
|
def test_requires_multi_disabled_inverse_legacy(config_type):
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
c = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': True,
|
|
'action': 'disabled', 'inverse': True},
|
|
{'option': b, 'expected': 1,
|
|
'action': 'disabled', 'inverse': True}])
|
|
od = OptionDescription('service', '', [a, b, c])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('num_service').value.set(1)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_requires_multi_disabled_inverse(config_type):
|
|
a = BoolOption('activate_service', '')
|
|
b = IntOption('num_service', '')
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition_0': ParamOption(a, notraisepropertyerror=True),
|
|
'condition_1': ParamOption(b, notraisepropertyerror=True),
|
|
'expected_0': ParamValue(True),
|
|
'expected_1': ParamValue(1),
|
|
'condition_operator': ParamValue('OR'),
|
|
'inverse_condition_0': ParamValue(True),
|
|
'inverse_condition_1': ParamValue(True)}))
|
|
c = IPOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b, c])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('num_service').value.set(1)
|
|
props = []
|
|
try:
|
|
cfg.option('ip_address_service').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
cfg.option('activate_service').value.set(True)
|
|
cfg.option('ip_address_service').value.get()
|
|
|
|
|
|
def test_requires_multi_disabled_2_legacy(config_type):
|
|
a = BoolOption('a', '')
|
|
b = BoolOption('b', '')
|
|
c = BoolOption('c', '')
|
|
d = BoolOption('d', '')
|
|
e = BoolOption('e', '')
|
|
f = BoolOption('f', '')
|
|
g = BoolOption('g', '')
|
|
h = BoolOption('h', '')
|
|
i = BoolOption('i', '')
|
|
j = BoolOption('j', '')
|
|
k = BoolOption('k', '')
|
|
l = BoolOption('l', '')
|
|
m = BoolOption('m', '')
|
|
list_bools = [a, b, c, d, e, f, g, h, i, j, k, l, m]
|
|
requires = []
|
|
for boo in list_bools:
|
|
requires.append({'option': boo, 'expected': True, 'action': 'disabled'})
|
|
z = IPOption('z', '', requires=requires)
|
|
y = copy(list_bools)
|
|
y.append(z)
|
|
od = OptionDescription('service', '', y)
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
cfg.option('z').value.get()
|
|
for boo in list_bools:
|
|
cfg.option(boo.impl_getname()).value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
for boo in list_bools:
|
|
cfg.option(boo.impl_getname()).value.set(False)
|
|
if boo == m:
|
|
cfg.option('z').value.get()
|
|
else:
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_multi_disabled_2(config_type):
|
|
a = BoolOption('a', '')
|
|
b = BoolOption('b', '')
|
|
c = BoolOption('c', '')
|
|
d = BoolOption('d', '')
|
|
e = BoolOption('e', '')
|
|
f = BoolOption('f', '')
|
|
g = BoolOption('g', '')
|
|
h = BoolOption('h', '')
|
|
i = BoolOption('i', '')
|
|
j = BoolOption('j', '')
|
|
k = BoolOption('k', '')
|
|
l = BoolOption('l', '')
|
|
m = BoolOption('m', '')
|
|
list_bools = [a, b, c, d, e, f, g, h, i, j, k, l, m]
|
|
requires = []
|
|
kwargs={'expected': ParamValue(True),
|
|
'condition_operator': ParamValue('OR')}
|
|
for idx, boo in enumerate(list_bools):
|
|
kwargs['condition_{}'.format(idx)] = ParamOption(boo, notraisepropertyerror=True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs=kwargs))
|
|
z = IPOption('z', '', properties=(disabled_property,))
|
|
y = copy(list_bools)
|
|
y.append(z)
|
|
od = OptionDescription('service', '', y)
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
cfg.option('z').value.get()
|
|
for boo in list_bools:
|
|
cfg.option(boo.impl_getname()).value.set(True)
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
for boo in list_bools:
|
|
cfg.option(boo.impl_getname()).value.set(False)
|
|
if boo == m:
|
|
cfg.option('z').value.get()
|
|
else:
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_multi_disabled_inverse_2_legacy(config_type):
|
|
a = BoolOption('a', '')
|
|
b = BoolOption('b', '')
|
|
c = BoolOption('c', '')
|
|
d = BoolOption('d', '')
|
|
e = BoolOption('e', '')
|
|
f = BoolOption('f', '')
|
|
g = BoolOption('g', '')
|
|
h = BoolOption('h', '')
|
|
i = BoolOption('i', '')
|
|
j = BoolOption('j', '')
|
|
k = BoolOption('k', '')
|
|
l = BoolOption('l', '')
|
|
m = BoolOption('m', '')
|
|
list_bools = [a, b, c, d, e, f, g, h, i, j, k, l, m]
|
|
requires = []
|
|
for boo in list_bools:
|
|
requires.append({'option': boo, 'expected': True, 'action': 'disabled',
|
|
'inverse': True})
|
|
z = IPOption('z', '', requires=requires)
|
|
y = copy(list_bools)
|
|
y.append(z)
|
|
od = OptionDescription('service', '', y)
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
for boo in list_bools:
|
|
cfg.option(boo.impl_getname()).value.set(True)
|
|
if boo == m:
|
|
cfg.option('z').value.get()
|
|
else:
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
for boo in list_bools:
|
|
cfg.option(boo.impl_getname()).value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
|
|
|
|
def test_requires_multi_disabled_inverse_2(config_type):
|
|
a = BoolOption('a', '')
|
|
b = BoolOption('b', '')
|
|
c = BoolOption('c', '')
|
|
d = BoolOption('d', '')
|
|
e = BoolOption('e', '')
|
|
f = BoolOption('f', '')
|
|
g = BoolOption('g', '')
|
|
h = BoolOption('h', '')
|
|
i = BoolOption('i', '')
|
|
j = BoolOption('j', '')
|
|
k = BoolOption('k', '')
|
|
l = BoolOption('l', '')
|
|
m = BoolOption('m', '')
|
|
list_bools = [a, b, c, d, e, f, g, h, i, j, k, l, m]
|
|
requires = []
|
|
kwargs={'expected': ParamValue(True),
|
|
'condition_operator': ParamValue('OR')}
|
|
for idx, boo in enumerate(list_bools):
|
|
kwargs['condition_{}'.format(idx)] = ParamOption(boo, notraisepropertyerror=True)
|
|
kwargs['inverse_condition_{}'.format(idx)] = ParamValue(True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs=kwargs))
|
|
#for boo in list_bools:
|
|
# requires.append({'option': boo, 'expected': True, 'action': 'disabled',
|
|
# 'inverse': True})
|
|
z = IPOption('z', '', properties=(disabled_property,))
|
|
y = copy(list_bools)
|
|
y.append(z)
|
|
od = OptionDescription('service', '', y)
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
for boo in list_bools:
|
|
cfg.option(boo.impl_getname()).value.set(True)
|
|
if boo != m:
|
|
# it's disabled until last option is modified
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('z').value.get()
|
|
for boo in list_bools:
|
|
cfg.option(boo.impl_getname()).value.set(False)
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
for boo in reversed(list_bools):
|
|
cfg.option(boo.impl_getname()).value.set(True)
|
|
if boo != a:
|
|
# it's disabled until last option is modified
|
|
props = []
|
|
try:
|
|
cfg.option('z').value.get()
|
|
except PropertiesOptionError as err:
|
|
props = err.proptype
|
|
assert frozenset(props) == frozenset(['disabled'])
|
|
cfg.option('z').value.get()
|
|
|
|
|
|
def test_requires_requirement_append_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg_ori = Config(od)
|
|
cfg_ori.property.read_write()
|
|
cfg = get_config(cfg_ori, config_type)
|
|
cfg.property.get()
|
|
cfg.option('ip_address_service').property.get()
|
|
if config_type == 'tiramisu-api':
|
|
cfg.send()
|
|
#raises(ValueError, "cfg_ori.option('ip_address_service').property.add('disabled')")
|
|
cfg = get_config(cfg_ori, config_type)
|
|
cfg.option('activate_service').value.set(False)
|
|
# disabled is now set, test to remove disabled before store in storage
|
|
if config_type == 'tiramisu-api':
|
|
cfg.send()
|
|
cfg_ori.unrestraint.option('ip_address_service').property.add("test")
|
|
|
|
|
|
def test_requires_requirement_append(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
b = IPOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg_ori = Config(od)
|
|
cfg_ori.property.read_write()
|
|
cfg = get_config(cfg_ori, config_type)
|
|
cfg.property.get()
|
|
cfg.option('ip_address_service').property.get()
|
|
if config_type == 'tiramisu-api':
|
|
cfg.send()
|
|
#raises(ValueError, "cfg_ori.option('ip_address_service').property.add('disabled')")
|
|
cfg = get_config(cfg_ori, config_type)
|
|
cfg.option('activate_service').value.set(False)
|
|
# disabled is now set, test to remove disabled before store in storage
|
|
if config_type == 'tiramisu-api':
|
|
cfg.send()
|
|
cfg_ori.unrestraint.option('ip_address_service').property.add("test")
|
|
|
|
|
|
def test_requires_different_inverse_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = IPOption('ip_address_service', '', requires=[
|
|
{'option': a, 'expected': True, 'action': 'disabled', 'inverse': True},
|
|
{'option': a, 'expected': True, 'action': 'disabled', 'inverse': False}])
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
raises(PropertiesOptionError, "cfg.option('ip_address_service').value.get()")
|
|
cfg.option('activate_service').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_address_service').value.get()")
|
|
|
|
|
|
def test_requires_different_inverse(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition_0': ParamOption(a, notraisepropertyerror=True),
|
|
'condition_1': ParamOption(a, notraisepropertyerror=True),
|
|
'expected_0': ParamValue(True),
|
|
'expected_1': ParamValue(True),
|
|
'condition_operator': ParamValue('OR'),
|
|
'inverse_condition_0': ParamValue(True)}))
|
|
b = IPOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
#raises(PropertiesOptionError, "cfg.option('ip_address_service').value.get()")
|
|
cfg.option('activate_service').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_address_service').value.get()")
|
|
|
|
|
|
def test_requires_different_inverse_unicode_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
d = StrOption('activate_other_service', '', 'val2')
|
|
b = IPOption('ip_address_service', '', requires=[
|
|
{'option': a, 'expected': True, 'action': 'disabled', 'inverse': True},
|
|
{'option': d, 'expected': 'val1', 'action': 'disabled', 'inverse': False}])
|
|
od = OptionDescription('service', '', [a, d, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.option('ip_address_service').value.get() == None
|
|
cfg.option('activate_service').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_address_service').value.get()")
|
|
cfg.option('activate_service').value.set(True)
|
|
assert cfg.option('ip_address_service').value.get() == None
|
|
cfg.option('activate_other_service').value.set('val1')
|
|
raises(PropertiesOptionError, "cfg.option('ip_address_service').value.get()")
|
|
cfg.option('activate_service').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_address_service').value.get()")
|
|
|
|
|
|
def test_requires_different_inverse_unicode(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
d = StrOption('activate_other_service', '', 'val2')
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition_0': ParamOption(a, notraisepropertyerror=True),
|
|
'condition_1': ParamOption(d, notraisepropertyerror=True),
|
|
'expected_0': ParamValue(True),
|
|
'expected_1': ParamValue('val1'),
|
|
'condition_operator': ParamValue('OR'),
|
|
'inverse_condition_0': ParamValue(True)}))
|
|
b = IPOption('ip_address_service', '', properties=(disabled_property,))
|
|
od = OptionDescription('service', '', [a, d, b])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.option('ip_address_service').value.get() == None
|
|
cfg.option('activate_service').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_address_service').value.get()")
|
|
cfg.option('activate_service').value.set(True)
|
|
assert cfg.option('ip_address_service').value.get() == None
|
|
cfg.option('activate_other_service').value.set('val1')
|
|
raises(PropertiesOptionError, "cfg.option('ip_address_service').value.get()")
|
|
cfg.option('activate_service').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_address_service').value.get()")
|
|
|
|
|
|
def test_requires_recursive_path_legacy(config_type):
|
|
a = BoolOption('activate_service', '', True)
|
|
b = IPOption('ip_address_service', '',
|
|
requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
od1 = OptionDescription('service', '', [a, b], requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('base', '', [od1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
if config_type == 'tiramisu-api':
|
|
raises(ConfigError, "get_config(cfg, config_type)")
|
|
else:
|
|
cfg = get_config(cfg, config_type)
|
|
raises(RequirementError, "cfg.option('service.a').value.get()")
|
|
|
|
|
|
def test_optiondescription_requires_legacy():
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('ip_address_service', '', multi=True)
|
|
OptionDescription('service', '', [b], requires=[{'option': a, 'expected': False, 'action': 'disabled'}])
|
|
|
|
|
|
def test_optiondescription_requires():
|
|
a = BoolOption('activate_service', '', True)
|
|
b = BoolOption('ip_address_service', '', multi=True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(a, notraisepropertyerror=True),
|
|
'expected': ParamValue(False)}))
|
|
OptionDescription('service', '', [b], properties=(disabled_property,))
|
|
|
|
|
|
def test_optiondescription_requires_multi_legacy():
|
|
# FIXME not legacy !!!
|
|
a = BoolOption('activate_service', '', True)
|
|
b = IPOption('ip_address_service', '', multi=True)
|
|
a, b
|
|
raises(ValueError, "OptionDescription('service', '', [a], requires=[{'option': b, 'expected': False, 'action': 'disabled'}])")
|
|
|
|
|
|
def test_properties_conflict_legacy():
|
|
a = BoolOption('activate_service', '', True)
|
|
a
|
|
raises(ValueError, "IPOption('ip_address_service', '', properties=('disabled',), requires=[{'option': a, 'expected': False, 'action': 'disabled'}])")
|
|
raises(ValueError, "od1 = OptionDescription('service', '', [a], properties=('disabled',), requires=[{'option': a, 'expected': False, 'action': 'disabled'}])")
|
|
|
|
|
|
def test_leadership_requires_legacy(config_type):
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
|
|
requires=[{'option': ip_admin_eth0, 'expected': '192.168.1.1', 'action': 'disabled'}])
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
|
|
od = OptionDescription('toto', '', [interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
#
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
#
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() is None
|
|
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('255.255.255.255')
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == '255.255.255.255'
|
|
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['192.168.1.2', '192.168.1.2'],
|
|
'ip_admin_eth0.netmask_admin_eth0': [None, '255.255.255.255']}
|
|
#
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
ret = cfg.value.dict()
|
|
assert set(ret.keys()) == set(['ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
|
|
assert ret['ip_admin_eth0.ip_admin_eth0'] == ['192.168.1.2', '192.168.1.1']
|
|
assert len(ret['ip_admin_eth0.netmask_admin_eth0']) == 2
|
|
assert ret['ip_admin_eth0.netmask_admin_eth0'][0] is None
|
|
assert isinstance(ret['ip_admin_eth0.netmask_admin_eth0'][1], PropertiesOptionError)
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][1]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][0]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0']
|
|
#
|
|
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('255.255.255.255')
|
|
ret = cfg.value.dict()
|
|
assert set(ret.keys()) == set(['ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
|
|
assert ret['ip_admin_eth0.ip_admin_eth0'] == ['192.168.1.2', '192.168.1.1']
|
|
assert len(ret['ip_admin_eth0.netmask_admin_eth0']) == 2
|
|
assert ret['ip_admin_eth0.netmask_admin_eth0'][0] == '255.255.255.255'
|
|
assert isinstance(ret['ip_admin_eth0.netmask_admin_eth0'][1], PropertiesOptionError)
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][1]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][0]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0']
|
|
|
|
|
|
def test_leadership_requires(config_type):
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(ip_admin_eth0, notraisepropertyerror=True),
|
|
'expected': ParamValue('192.168.1.1'),
|
|
'no_condition_is_invalid': ParamValue(True),
|
|
'index': ParamIndex()}))
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True, properties=(disabled_property,))
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
|
|
od = OptionDescription('toto', '', [interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
#
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
#
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() is None
|
|
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('255.255.255.255')
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == '255.255.255.255'
|
|
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['192.168.1.2', '192.168.1.2'],
|
|
'ip_admin_eth0.netmask_admin_eth0': [None, '255.255.255.255']}
|
|
#
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
ret = cfg.value.dict()
|
|
assert set(ret.keys()) == set(['ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
|
|
assert ret['ip_admin_eth0.ip_admin_eth0'] == ['192.168.1.2', '192.168.1.1']
|
|
assert len(ret['ip_admin_eth0.netmask_admin_eth0']) == 2
|
|
assert ret['ip_admin_eth0.netmask_admin_eth0'][0] is None
|
|
assert isinstance(ret['ip_admin_eth0.netmask_admin_eth0'][1], PropertiesOptionError)
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][1]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][0]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0']
|
|
#
|
|
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('255.255.255.255')
|
|
ret = cfg.value.dict()
|
|
assert set(ret.keys()) == set(['ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
|
|
assert ret['ip_admin_eth0.ip_admin_eth0'] == ['192.168.1.2', '192.168.1.1']
|
|
assert len(ret['ip_admin_eth0.netmask_admin_eth0']) == 2
|
|
assert ret['ip_admin_eth0.netmask_admin_eth0'][0] == '255.255.255.255'
|
|
assert isinstance(ret['ip_admin_eth0.netmask_admin_eth0'][1], PropertiesOptionError)
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][1]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][0]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0']
|
|
|
|
|
|
def test_leadership_requires_callback_legacy(config_type):
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
|
|
requires=[{'callback': calc_value, 'callback_params': Params(ParamOption(ip_admin_eth0)), 'expected': '192.168.1.1', 'action': 'disabled'}])
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
|
|
od = OptionDescription('toto', '', [interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
#
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
#
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() is None
|
|
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('255.255.255.255')
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == '255.255.255.255'
|
|
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['192.168.1.2', '192.168.1.2'],
|
|
'ip_admin_eth0.netmask_admin_eth0': [None, '255.255.255.255']}
|
|
#
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
ret = cfg.value.dict()
|
|
assert set(ret.keys()) == set(['ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
|
|
assert ret['ip_admin_eth0.ip_admin_eth0'] == ['192.168.1.2', '192.168.1.1']
|
|
assert len(ret['ip_admin_eth0.netmask_admin_eth0']) == 2
|
|
assert ret['ip_admin_eth0.netmask_admin_eth0'][0] is None
|
|
assert isinstance(ret['ip_admin_eth0.netmask_admin_eth0'][1], PropertiesOptionError)
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][1]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][0]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0']
|
|
#
|
|
cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.set('255.255.255.255')
|
|
ret = cfg.value.dict()
|
|
assert set(ret.keys()) == set(['ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'])
|
|
assert ret['ip_admin_eth0.ip_admin_eth0'] == ['192.168.1.2', '192.168.1.1']
|
|
assert len(ret['ip_admin_eth0.netmask_admin_eth0']) == 2
|
|
assert ret['ip_admin_eth0.netmask_admin_eth0'][0] == '255.255.255.255'
|
|
assert isinstance(ret['ip_admin_eth0.netmask_admin_eth0'][1], PropertiesOptionError)
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][1]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0'][0]
|
|
del ret['ip_admin_eth0.netmask_admin_eth0']
|
|
|
|
|
|
def test_leadership_requires_both_legacy():
|
|
# FIXME ne devrait pas pouvoir mettre de propriété calculé sur une master ...
|
|
ip_admin = StrOption('ip_admin_eth0', "ip réseau autorisé")
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
|
|
requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
|
|
raises(RequirementError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])")
|
|
|
|
|
|
def test_leadership_requires_properties_invalid_legacy():
|
|
ip_admin = StrOption('ip_admin', "ip réseau autorisé")
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
|
|
requires=[{'option': ip_admin_eth0, 'expected': '192.168.1.1', 'action': 'disabled'}])
|
|
raises(ValueError, "Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], properties=('disabled',), requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])")
|
|
|
|
|
|
def test_leadership_requires_properties_legacy():
|
|
ip_admin = StrOption('ip_admin', "ip réseau autorisé")
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
|
|
requires=[{'option': ip_admin_eth0, 'expected': '192.168.1.1', 'action': 'disabled'}])
|
|
Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], properties=('hidden',),
|
|
requires=[{'option': ip_admin, 'expected': '192.168.1.1', 'action': 'disabled'}])
|
|
|
|
|
|
def test_leadership_requires_leader_legacy(config_type):
|
|
activate = BoolOption('activate', "Activer l'accès au réseau", True)
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
|
|
requires=[{'option': activate, 'expected': False, 'action': 'disabled'}])
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
|
|
od = OptionDescription('toto', '', [activate, interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
|
|
#
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
#
|
|
cfg.option('activate').value.set(True)
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
assert cfg.value.dict() == {'activate': False}
|
|
|
|
|
|
def test_leadership_requires_leader(config_type):
|
|
activate = BoolOption('activate', "Activer l'accès au réseau", True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(activate, notraisepropertyerror=True),
|
|
'expected': ParamValue(False),
|
|
'index': ParamIndex()}))
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True, properties=(disabled_property,))
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
|
|
od = OptionDescription('toto', '', [activate, interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
|
|
#
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
#
|
|
cfg.option('activate').value.set(True)
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
assert cfg.value.dict() == {'activate': False}
|
|
|
|
|
|
def test_leadership_requires_leader_callback_legacy(config_type):
|
|
activate = BoolOption('activate', "Activer l'accès au réseau", True)
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True,
|
|
requires=[{'callback': calc_value, 'callback_params': Params(ParamOption(activate)), 'expected': False, 'action': 'disabled'}])
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
|
|
od = OptionDescription('toto', '', [activate, interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
#
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
#
|
|
cfg.option('activate').value.set(True)
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
assert cfg.value.dict() == {'activate': False}
|
|
|
|
|
|
def test_leadership_requires_leadership_legacy(config_type):
|
|
activate = BoolOption('activate', "Activer l'accès au réseau", True)
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0],
|
|
requires=[{'option': activate, 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('toto', '', [activate, interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
#
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
if config_type != 'tiramisu-api':
|
|
# FIXME
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
#
|
|
cfg.option('activate').value.set(True)
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
if config_type != 'tiramisu-api':
|
|
# FIXME
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
assert cfg.value.dict() == {'activate': False}
|
|
|
|
|
|
def test_leadership_requires_leadership(config_type):
|
|
activate = BoolOption('activate', "Activer l'accès au réseau", True)
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(activate, notraisepropertyerror=True),
|
|
'expected': ParamValue(False),
|
|
'index': ParamIndex()}))
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0], properties=(disabled_property,))
|
|
od = OptionDescription('toto', '', [activate, interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
#
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
if config_type != 'tiramisu-api':
|
|
# FIXME
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
#
|
|
cfg.option('activate').value.set(True)
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
if config_type != 'tiramisu-api':
|
|
# FIXME
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
assert cfg.value.dict() == {'activate': False}
|
|
|
|
|
|
def test_leadership_requires_leadership_callback_legacy(config_type):
|
|
activate = BoolOption('activate', "Activer l'accès au réseau", True)
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True)
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0],
|
|
requires=[{'callback': calc_value, 'callback_params': Params(ParamOption(activate)), 'expected': False, 'action': 'disabled'}])
|
|
od = OptionDescription('toto', '', [activate, interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
#
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
#
|
|
cfg.option('activate').value.set(True)
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
#
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.ip_admin_eth0').value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
assert cfg.value.dict() == {'activate': False}
|
|
|
|
|
|
def test_leadership_requires_no_leader_legacy(config_type):
|
|
activate = BoolOption('activate', "Activer l'accès au réseau", True)
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
|
|
requires=[{'option': activate, 'expected': False, 'action': 'disabled'}])
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
|
|
od = OptionDescription('toto', '', [activate, interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
cfg.option('activate').value.set(False)
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2', '192.168.1.1']
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
cfg.option('activate').value.set(True)
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() is None
|
|
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('255.255.255.255')
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == '255.255.255.255'
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['192.168.1.2', '192.168.1.1'], 'activate': False}
|
|
|
|
|
|
def test_leadership_requires_no_leader(config_type):
|
|
activate = BoolOption('activate', "Activer l'accès au réseau", True)
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(activate, notraisepropertyerror=True),
|
|
'expected': ParamValue(False),
|
|
'index': ParamIndex()}))
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True, properties=(disabled_property,))
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
|
|
od = OptionDescription('toto', '', [activate, interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
cfg.option('activate').value.set(False)
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2', '192.168.1.1']
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
cfg.option('activate').value.set(True)
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() is None
|
|
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('255.255.255.255')
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == '255.255.255.255'
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
assert cfg.value.dict() == {'ip_admin_eth0.ip_admin_eth0': ['192.168.1.2', '192.168.1.1'], 'activate': False}
|
|
|
|
|
|
def test_leadership_requires_no_leader_callback_legacy(config_type):
|
|
activate = BoolOption('activate', "Activer l'accès au réseau", True)
|
|
ip_admin_eth0 = StrOption('ip_admin_eth0', "ip réseau autorisé", multi=True)
|
|
netmask_admin_eth0 = StrOption('netmask_admin_eth0', "masque du sous-réseau", multi=True,
|
|
requires=[{'callback': calc_value, 'callback_params': Params(ParamOption(activate)), 'expected': False, 'action': 'disabled'}])
|
|
interface1 = Leadership('ip_admin_eth0', '', [ip_admin_eth0, netmask_admin_eth0])
|
|
od = OptionDescription('toto', '', [activate, interface1])
|
|
cfg = Config(od)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == []
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2'])
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2']
|
|
cfg.option('activate').value.set(False)
|
|
cfg.option('ip_admin_eth0.ip_admin_eth0').value.set(['192.168.1.2', '192.168.1.1'])
|
|
assert cfg.option('ip_admin_eth0.ip_admin_eth0').value.get() == ['192.168.1.2', '192.168.1.1']
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
cfg.option('activate').value.set(True)
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get() is None
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() is None
|
|
cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.set('255.255.255.255')
|
|
assert cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get() == '255.255.255.255'
|
|
cfg.option('activate').value.set(False)
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 0).value.get()")
|
|
raises(PropertiesOptionError, "cfg.option('ip_admin_eth0.netmask_admin_eth0', 1).value.get()")
|
|
dico = cfg.value.dict()
|
|
assert set(dico.keys()) == {'activate', 'ip_admin_eth0.ip_admin_eth0', 'ip_admin_eth0.netmask_admin_eth0'}
|
|
dico['ip_admin_eth0.ip_admin_eth0'] == ['192.168.1.2', '192.168.1.1']
|
|
dico['activate'] == False
|
|
del dico['ip_admin_eth0.netmask_admin_eth0'][1]
|
|
del dico['ip_admin_eth0.netmask_admin_eth0'][0]
|
|
|
|
|
|
def test_leadership_requires_complet_legacy(config_type):
|
|
optiontoto = StrOption('unicodetoto', "Unicode")
|
|
option = StrOption('unicode', "Unicode leader", multi=True)
|
|
option1 = StrOption('unicode1', "Unicode follower 1", multi=True)
|
|
option2 = StrOption('unicode2', "Values 'test' must show 'Unicode follower 3'", multi=True)
|
|
option3 = StrOption('unicode3', "Unicode follower 3", requires=[{'option': option,
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True}],
|
|
multi=True)
|
|
option4 = StrOption('unicode4', "Unicode follower 4", requires=[{'option': option2,
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True}],
|
|
multi=True)
|
|
option5 = StrOption('unicode5', "Unicode follower 5", requires=[{'option': optiontoto,
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True}],
|
|
multi=True)
|
|
option6 = StrOption('unicode6', "Unicode follower 6", requires=[{'option': optiontoto,
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True},
|
|
{'option': option2,
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True}],
|
|
multi=True)
|
|
option7 = StrOption('unicode7', "Unicode follower 7", requires=[{'option': option2,
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True},
|
|
{'option': optiontoto,
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True}],
|
|
multi=True)
|
|
descr1 = Leadership("unicode", "Common configuration 1",
|
|
[option, option1, option2, option3, option4, option5, option6, option7])
|
|
descr = OptionDescription("options", "Common configuration 2", [descr1, optiontoto])
|
|
descr = OptionDescription("unicode1_leadership_requires", "Leader followers with Unicode follower 3 hidden when Unicode follower 2 is test", [descr])
|
|
cfg = Config(descr)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('options.unicode.unicode').value.set(['test', 'trah'])
|
|
cfg.option('options.unicode.unicode2', 0).value.set('test')
|
|
dico = cfg.value.dict()
|
|
assert dico.keys() == set(['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto'])
|
|
assert dico['options.unicode.unicode'] == ['test', 'trah']
|
|
assert dico['options.unicode.unicode1'] == [None, None]
|
|
assert dico['options.unicode.unicode2'] == ['test', None]
|
|
assert dico['options.unicode.unicode3'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode4'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert dico['options.unicodetoto'] is None
|
|
del dico['options.unicode.unicode3'][1]
|
|
del dico['options.unicode.unicode3']
|
|
del dico['options.unicode.unicode4'][1]
|
|
del dico['options.unicode.unicode4']
|
|
#
|
|
cfg.option('options.unicodetoto').value.set('test')
|
|
dico = cfg.value.dict()
|
|
assert dico.keys() == set(['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicode.unicode5', 'options.unicode.unicode6', 'options.unicode.unicode7', 'options.unicodetoto'])
|
|
assert dico['options.unicode.unicode'] == ['test', 'trah']
|
|
assert dico['options.unicode.unicode1'] == [None, None]
|
|
assert dico['options.unicode.unicode2'] == ['test', None]
|
|
assert dico['options.unicode.unicode3'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode4'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode5'] == [None, None]
|
|
assert dico['options.unicode.unicode6'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode6'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode7'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode7'][1], PropertiesOptionError)
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
del dico['options.unicode.unicode3'][1]
|
|
del dico['options.unicode.unicode3']
|
|
del dico['options.unicode.unicode4'][1]
|
|
del dico['options.unicode.unicode4']
|
|
del dico['options.unicode.unicode6'][1]
|
|
del dico['options.unicode.unicode6']
|
|
del dico['options.unicode.unicode7'][1]
|
|
del dico['options.unicode.unicode7']
|
|
|
|
|
|
def test_leadership_requires_complet(config_type):
|
|
optiontoto = StrOption('unicodetoto', "Unicode")
|
|
option = StrOption('unicode', "Unicode leader", multi=True)
|
|
option1 = StrOption('unicode1', "Unicode follower 1", multi=True)
|
|
option2 = StrOption('unicode2', "Values 'test' must show 'Unicode follower 3'", multi=True)
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition': ParamOption(option, notraisepropertyerror=True),
|
|
'expected': ParamValue('test'),
|
|
'index': ParamIndex(),
|
|
'no_condition_is_invalid': ParamValue(True),
|
|
'inverse_condition': ParamValue(True)}))
|
|
option3 = StrOption('unicode3', "Unicode follower 3", properties=(hidden_property,), multi=True)
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition': ParamOption(option2, notraisepropertyerror=True),
|
|
'expected': ParamValue('test'),
|
|
'no_condition_is_invalid': ParamValue(True),
|
|
'index': ParamIndex(),
|
|
'inverse_condition': ParamValue(True)}))
|
|
option4 = StrOption('unicode4', "Unicode follower 4", properties=(hidden_property,), multi=True)
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition': ParamOption(optiontoto, notraisepropertyerror=True),
|
|
'expected': ParamValue('test'),
|
|
'no_condition_is_invalid': ParamValue(True),
|
|
'inverse_condition': ParamValue(True)}))
|
|
option5 = StrOption('unicode5', "Unicode follower 5", properties=(hidden_property,), multi=True)
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition_0': ParamOption(optiontoto, notraisepropertyerror=True),
|
|
'expected_0': ParamValue('test'),
|
|
'condition_1': ParamOption(option2, notraisepropertyerror=True),
|
|
'expected_1': ParamValue('test'),
|
|
'no_condition_is_invalid': ParamValue(True),
|
|
'index': ParamIndex(),
|
|
'condition_operator': ParamValue('OR'),
|
|
'inverse_condition_0': ParamValue(True),
|
|
'inverse_condition_1': ParamValue(True)}))
|
|
option6 = StrOption('unicode6', "Unicode follower 6", properties=(hidden_property,), multi=True)
|
|
hidden_property = Calculation(calc_value,
|
|
Params(ParamValue('hidden'),
|
|
kwargs={'condition_0': ParamOption(option2, notraisepropertyerror=True),
|
|
'expected_0': ParamValue('test'),
|
|
'condition_1': ParamOption(optiontoto, notraisepropertyerror=True),
|
|
'expected_1': ParamValue('test'),
|
|
'no_condition_is_invalid': ParamValue(True),
|
|
'index': ParamIndex(),
|
|
'inverse_condition': ParamValue(True)}))
|
|
option7 = StrOption('unicode7', "Unicode follower 7", properties=(hidden_property,), multi=True)
|
|
descr1 = Leadership("unicode", "Common configuration 1",
|
|
[option, option1, option2, option3, option4, option5, option6, option7])
|
|
descr = OptionDescription("options", "Common configuration 2", [descr1, optiontoto])
|
|
descr = OptionDescription("unicode1_leadership_requires", "Leader followers with Unicode follower 3 hidden when Unicode follower 2 is test", [descr])
|
|
cfg = Config(descr)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('options.unicode.unicode').value.set(['test', 'trah'])
|
|
cfg.option('options.unicode.unicode2', 0).value.set('test')
|
|
dico = cfg.value.dict()
|
|
assert dico.keys() == set(['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto'])
|
|
assert dico['options.unicode.unicode'] == ['test', 'trah']
|
|
assert dico['options.unicode.unicode1'] == [None, None]
|
|
assert dico['options.unicode.unicode2'] == ['test', None]
|
|
assert dico['options.unicode.unicode3'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode4'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert dico['options.unicodetoto'] is None
|
|
del dico['options.unicode.unicode3'][1]
|
|
del dico['options.unicode.unicode3']
|
|
del dico['options.unicode.unicode4'][1]
|
|
del dico['options.unicode.unicode4']
|
|
#
|
|
cfg.option('options.unicodetoto').value.set('test')
|
|
dico = cfg.value.dict()
|
|
assert dico.keys() == set(['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicode.unicode5', 'options.unicode.unicode6', 'options.unicode.unicode7', 'options.unicodetoto'])
|
|
assert dico['options.unicode.unicode'] == ['test', 'trah']
|
|
assert dico['options.unicode.unicode1'] == [None, None]
|
|
assert dico['options.unicode.unicode2'] == ['test', None]
|
|
assert dico['options.unicode.unicode3'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode4'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode5'] == [None, None]
|
|
assert dico['options.unicode.unicode6'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode6'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode7'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode7'][1], PropertiesOptionError)
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
del dico['options.unicode.unicode3'][1]
|
|
del dico['options.unicode.unicode3']
|
|
del dico['options.unicode.unicode4'][1]
|
|
del dico['options.unicode.unicode4']
|
|
del dico['options.unicode.unicode6'][1]
|
|
del dico['options.unicode.unicode6']
|
|
del dico['options.unicode.unicode7'][1]
|
|
del dico['options.unicode.unicode7']
|
|
|
|
|
|
def test_leadership_requires_complet_callback_legacy(config_type):
|
|
optiontoto = StrOption('unicodetoto', "Unicode leader")
|
|
option = StrOption('unicode', "Unicode leader", multi=True)
|
|
option1 = StrOption('unicode1', "Unicode follower 1", multi=True)
|
|
option2 = StrOption('unicode2', "Values 'test' must show 'Unicode follower 3'", multi=True)
|
|
option3 = StrOption('unicode3', "Unicode follower 3", requires=[{'callback': calc_value,
|
|
'callback_params': Params(ParamOption(option)),
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True}],
|
|
multi=True)
|
|
option4 = StrOption('unicode4', "Unicode follower 4", requires=[{'callback': calc_value,
|
|
'callback_params': Params(ParamOption(option2)),
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True}],
|
|
multi=True)
|
|
option5 = StrOption('unicode5', "Unicode follower 5", requires=[{'callback': calc_value,
|
|
'callback_params': Params(ParamOption(optiontoto)),
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True}],
|
|
multi=True)
|
|
option6 = StrOption('unicode6', "Unicode follower 6", requires=[{'callback': calc_value,
|
|
'callback_params': Params(ParamOption(optiontoto)),
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True},
|
|
{'callback': calc_value,
|
|
'callback_params': Params(ParamOption(option2)),
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True}],
|
|
multi=True)
|
|
option7 = StrOption('unicode7', "Unicode follower 7", requires=[{'callback': calc_value,
|
|
'callback_params': Params(ParamOption(option2)),
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True},
|
|
{'callback': calc_value,
|
|
'callback_params': Params(ParamOption(optiontoto)),
|
|
'expected': u'test',
|
|
'action': 'hidden',
|
|
'inverse': True}],
|
|
multi=True)
|
|
descr1 = Leadership("unicode", "Common configuration 1",
|
|
[option, option1, option2, option3, option4, option5, option6, option7])
|
|
descr = OptionDescription("options", "Common configuration 2", [descr1, optiontoto])
|
|
descr = OptionDescription("unicode1_leadership_requires", "Leader followers with Unicode follower 3 hidden when Unicode follower 2 is test", [descr])
|
|
cfg = Config(descr)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
cfg.option('options.unicode.unicode').value.set(['test', 'trah'])
|
|
cfg.option('options.unicode.unicode2', 0).value.set('test')
|
|
dico = cfg.value.dict()
|
|
assert dico.keys() == set(['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicode.unicode5', 'options.unicode.unicode6', 'options.unicode.unicode7', 'options.unicodetoto'])
|
|
assert dico['options.unicode.unicode'] == ['test', 'trah']
|
|
assert dico['options.unicode.unicode1'] == [None, None]
|
|
assert dico['options.unicode.unicode2'] == ['test', None]
|
|
assert dico['options.unicode.unicode3'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode4'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert dico['options.unicodetoto'] is None
|
|
del dico['options.unicode.unicode3'][1]
|
|
del dico['options.unicode.unicode3']
|
|
del dico['options.unicode.unicode4'][1]
|
|
del dico['options.unicode.unicode4']
|
|
del dico['options.unicode.unicode5'][0]
|
|
del dico['options.unicode.unicode5'][0]
|
|
del dico['options.unicode.unicode6'][0]
|
|
del dico['options.unicode.unicode6'][0]
|
|
del dico['options.unicode.unicode7'][0]
|
|
del dico['options.unicode.unicode7'][0]
|
|
#
|
|
cfg.option('options.unicodetoto').value.set('test')
|
|
dico = cfg.value.dict()
|
|
assert dico.keys() == set(['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicode.unicode5', 'options.unicode.unicode6', 'options.unicode.unicode7', 'options.unicodetoto'])
|
|
assert dico['options.unicode.unicode'] == ['test', 'trah']
|
|
assert dico['options.unicode.unicode1'] == [None, None]
|
|
assert dico['options.unicode.unicode2'] == ['test', None]
|
|
assert dico['options.unicode.unicode3'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode4'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode5'] == [None, None]
|
|
assert dico['options.unicode.unicode6'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode6'][1], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode7'][0] is None
|
|
assert isinstance(dico['options.unicode.unicode7'][1], PropertiesOptionError)
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
del dico['options.unicode.unicode3'][1]
|
|
del dico['options.unicode.unicode3']
|
|
del dico['options.unicode.unicode4'][1]
|
|
del dico['options.unicode.unicode4']
|
|
del dico['options.unicode.unicode6'][1]
|
|
del dico['options.unicode.unicode6']
|
|
del dico['options.unicode.unicode7'][1]
|
|
del dico['options.unicode.unicode7']
|
|
|
|
|
|
def test_leadership_requires_transitive1_legacy(config_type):
|
|
optiontoto = StrOption('unicodetoto', "Simple unicode")
|
|
option = StrOption('unicode', "Unicode leader", multi=True)
|
|
option1 = StrOption('unicode1', "Unicode follower 1", multi=True)
|
|
option2 = StrOption('unicode2', "Unicode follower 2", requires=[{'option': optiontoto,
|
|
'expected': u'test',
|
|
'action': 'disabled',
|
|
'transitive': True,
|
|
'inverse': True}],
|
|
multi=True)
|
|
option3 = StrOption('unicode3', "Unicode follower 3", requires=[{'option': option2,
|
|
'expected': u'test',
|
|
'action': 'disabled',
|
|
'transitive': True,
|
|
'inverse': True}],
|
|
multi=True)
|
|
option4 = StrOption('unicode4', "Unicode follower 4", requires=[{'option': option3,
|
|
'expected': u'test',
|
|
'action': 'disabled',
|
|
'transitive': True,
|
|
'inverse': True}],
|
|
multi=True)
|
|
descr1 = Leadership("unicode", "Common configuration 1",
|
|
[option, option1, option2, option3, option4])
|
|
descr = OptionDescription("options", "Common configuration 2", [descr1, optiontoto])
|
|
descr = OptionDescription("unicode1", "", [descr])
|
|
cfg = Config(descr)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.value.dict() == {'options.unicode.unicode': [], 'options.unicode.unicode1': [], 'options.unicode.unicode3': [], 'options.unicode.unicode4': [], 'options.unicodetoto': None}
|
|
#
|
|
cfg.option('options.unicodetoto').value.set('test')
|
|
assert cfg.value.dict() == {'options.unicode.unicode': [], 'options.unicode.unicode1': [], 'options.unicode.unicode2': [], 'options.unicode.unicode3': [], 'options.unicode.unicode4': [], 'options.unicodetoto': 'test'}
|
|
#
|
|
cfg.option('options.unicode.unicode').value.set(['a', 'b', 'c'])
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert dico['options.unicode.unicode2'] == [None, None, None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
#
|
|
cfg.option('options.unicode.unicode2', 1).value.set('test')
|
|
cfg.option('options.unicode.unicode3', 1).value.set('test')
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert dico['options.unicode.unicode2'] == [None, 'test', None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode3'][1] == 'test'
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode4'][1] == None
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
#
|
|
cfg.option('options.unicode.unicode2', 1).value.set('rah')
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert dico['options.unicode.unicode2'] == [None, 'rah', None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
#
|
|
cfg.option('options.unicode.unicode2', 1).value.set('test')
|
|
cfg.option('options.unicodetoto').value.set('rah')
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'rah'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
|
|
|
|
def test_leadership_requires_transitive1(config_type):
|
|
optiontoto = StrOption('unicodetoto', "Simple unicode")
|
|
option = StrOption('unicode', "Unicode leader", multi=True)
|
|
option1 = StrOption('unicode1', "Unicode follower 1", multi=True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(optiontoto, raisepropertyerror=True),
|
|
'expected': ParamValue('test'),
|
|
'index': ParamIndex(),
|
|
'inverse_condition': ParamValue(True)}))
|
|
option2 = StrOption('unicode2', "Unicode follower 2", properties=(disabled_property,), multi=True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(option2, raisepropertyerror=True),
|
|
'expected': ParamValue('test'),
|
|
'index': ParamIndex(),
|
|
'no_condition_is_invalid': ParamValue(True),
|
|
'inverse_condition': ParamValue(True)}))
|
|
option3 = StrOption('unicode3', "Unicode follower 3", properties=(disabled_property,), multi=True)
|
|
disabled_property = Calculation(calc_value,
|
|
Params(ParamValue('disabled'),
|
|
kwargs={'condition': ParamOption(option3, raisepropertyerror=True),
|
|
'expected': ParamValue('test'),
|
|
'index': ParamIndex(),
|
|
'no_condition_is_invalid': ParamValue(True),
|
|
'inverse_condition': ParamValue(True)}))
|
|
option4 = StrOption('unicode4', "Unicode follower 4", properties=(disabled_property,), multi=True)
|
|
descr1 = Leadership("unicode", "Common configuration 1",
|
|
[option, option1, option2, option3, option4])
|
|
descr = OptionDescription("options", "Common configuration 2", [descr1, optiontoto])
|
|
descr = OptionDescription("unicode1", "", [descr])
|
|
cfg = Config(descr)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.value.dict() == {'options.unicode.unicode': [], 'options.unicode.unicode1': [], 'options.unicode.unicode3': [], 'options.unicode.unicode4': [], 'options.unicodetoto': None}
|
|
#
|
|
cfg.option('options.unicodetoto').value.set('test')
|
|
assert cfg.value.dict() == {'options.unicode.unicode': [], 'options.unicode.unicode1': [], 'options.unicode.unicode2': [], 'options.unicode.unicode3': [], 'options.unicode.unicode4': [], 'options.unicodetoto': 'test'}
|
|
#
|
|
cfg.option('options.unicode.unicode').value.set(['a', 'b', 'c'])
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert dico['options.unicode.unicode2'] == [None, None, None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
#
|
|
cfg.option('options.unicode.unicode2', 1).value.set('test')
|
|
cfg.option('options.unicode.unicode3', 1).value.set('test')
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert dico['options.unicode.unicode2'] == [None, 'test', None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode3'][1] == 'test'
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode4'][1] == None
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
#
|
|
cfg.option('options.unicode.unicode2', 1).value.set('rah')
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert dico['options.unicode.unicode2'] == [None, 'rah', None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
#
|
|
cfg.option('options.unicode.unicode2', 1).value.set('test')
|
|
cfg.option('options.unicodetoto').value.set('rah')
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'rah'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
|
|
|
|
def test_leadership_requires_transitive_callback_legacy(config_type):
|
|
optiontoto = StrOption('unicodetoto', "Unicode leader")
|
|
option = StrOption('unicode', "Unicode leader", multi=True)
|
|
option1 = StrOption('unicode1', "Unicode follower 1", multi=True)
|
|
option2 = StrOption('unicode2', "Unicode follower 2", requires=[{'callback': calc_value,
|
|
'callback_params': Params(ParamOption(optiontoto)),
|
|
'expected': u'test',
|
|
'action': 'disabled',
|
|
'transitive': True,
|
|
'inverse': True}],
|
|
multi=True)
|
|
option3 = StrOption('unicode3', "Unicode follower 3", requires=[{'callback': calc_value,
|
|
'callback_params': Params(ParamOption(option2)),
|
|
'expected': u'test',
|
|
'action': 'disabled',
|
|
'transitive': True,
|
|
'inverse': True}],
|
|
multi=True)
|
|
option4 = StrOption('unicode4', "Unicode follower 4", requires=[{'callback': calc_value,
|
|
'callback_params': Params(ParamOption(option3)),
|
|
'expected': u'test',
|
|
'action': 'disabled',
|
|
'transitive': True,
|
|
'inverse': True}],
|
|
multi=True)
|
|
descr1 = Leadership("unicode", "Common configuration 1",
|
|
[option, option1, option2, option3, option4])
|
|
descr = OptionDescription("options", "Common configuration 2", [descr1, optiontoto])
|
|
descr = OptionDescription("unicode1", "", [descr])
|
|
cfg = Config(descr)
|
|
cfg.property.read_write()
|
|
cfg = get_config(cfg, config_type)
|
|
assert cfg.value.dict() == {'options.unicode.unicode': [], 'options.unicode.unicode1': [], 'options.unicode.unicode2': [], 'options.unicode.unicode3': [], 'options.unicode.unicode4': [], 'options.unicodetoto': None}
|
|
#
|
|
cfg.option('options.unicodetoto').value.set('test')
|
|
assert cfg.value.dict() == {'options.unicode.unicode': [], 'options.unicode.unicode1': [], 'options.unicode.unicode2': [], 'options.unicode.unicode3': [], 'options.unicode.unicode4': [], 'options.unicodetoto': 'test'}
|
|
#
|
|
cfg.option('options.unicode.unicode').value.set(['a', 'b', 'c'])
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert dico['options.unicode.unicode2'] == [None, None, None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
#
|
|
cfg.option('options.unicode.unicode2', 1).value.set('test')
|
|
cfg.option('options.unicode.unicode3', 1).value.set('test')
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert dico['options.unicode.unicode2'] == [None, 'test', None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode3'][1] == 'test'
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert dico['options.unicode.unicode4'][1] == None
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
#
|
|
cfg.option('options.unicode.unicode2', 1).value.set('rah')
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'test'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert dico['options.unicode.unicode2'] == [None, 'rah', None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
#
|
|
cfg.option('options.unicode.unicode2', 1).value.set('test')
|
|
cfg.option('options.unicodetoto').value.set('rah')
|
|
dico = cfg.value.dict()
|
|
assert list(dico.keys()) == ['options.unicode.unicode', 'options.unicode.unicode1', 'options.unicode.unicode2', 'options.unicode.unicode3', 'options.unicode.unicode4', 'options.unicodetoto']
|
|
assert dico['options.unicodetoto'] == 'rah'
|
|
assert dico['options.unicode.unicode'] == ['a', 'b', 'c']
|
|
assert dico['options.unicode.unicode1'] == [None, None, None]
|
|
assert isinstance(dico['options.unicode.unicode3'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode3'][2], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][0], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][1], PropertiesOptionError)
|
|
assert isinstance(dico['options.unicode.unicode4'][2], PropertiesOptionError)
|
|
del (dico['options.unicode.unicode2'][2])
|
|
del (dico['options.unicode.unicode2'][1])
|
|
del (dico['options.unicode.unicode2'][0])
|
|
del (dico['options.unicode.unicode3'][2])
|
|
del (dico['options.unicode.unicode3'][1])
|
|
del (dico['options.unicode.unicode3'][0])
|
|
del (dico['options.unicode.unicode4'][2])
|
|
del (dico['options.unicode.unicode4'][1])
|
|
del (dico['options.unicode.unicode4'][0])
|
|
|
|
|
|
# FIXME tester l'ajout d'un Calculation
|
|
# FIXME permissive peut etre in calcul !
|
|
# FIXME Calculation sur des multis ...
|