"config.set() or config.setoption() or option.setoption()" from .autopath import do_autopath do_autopath() import pytest from os import environ from tiramisu.i18n import _ from tiramisu.error import display_list, ConfigError from tiramisu.setting import owners, groups from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \ StrOption, OptionDescription, Leadership, Config, undefined, \ Calculation, Params, ParamOption, ParamValue, ParamIndex, \ calc_value, calc_value_property_help from tiramisu.error import PropertiesOptionError from tiramisu.storage import list_sessions import warnings from .config import config_type, get_config, event_loop def make_description(): gcoption = ChoiceOption('name', 'GC name', ('ref', 'framework'), 'ref') gcdummy = BoolOption('dummy', 'dummy', default=False) objspaceoption = ChoiceOption('objspace', 'Object space', ('std', 'thunk'), 'std') booloption = BoolOption('bool', 'Test boolean option', default=True) intoption = IntOption('int', 'Test int option', default=0) floatoption = FloatOption('float', 'Test float option', default=2.3) stroption = StrOption('str', 'Test string option', default="abc") boolop = BoolOption('boolop', 'Test boolean option op', default=True) wantref_option = BoolOption('wantref', 'Test requires', default=False) wantframework_option = BoolOption('wantframework', 'Test requires', default=False) gcgroup = OptionDescription('gc', '', [gcoption, gcdummy, floatoption]) descr = OptionDescription('tiramisu', '', [gcgroup, booloption, objspaceoption, wantref_option, stroption, wantframework_option, intoption, boolop]) return descr #____________________________________________________________ # change with __setattr__ @pytest.mark.asyncio async def test_attribute_access(config_type): "Once set, option values can't be changed again by attribute access" s = StrOption("string", "", default="string") descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: cfg = await get_config(cfg, config_type) # let's try to change it again await cfg.option('string').value.set('foo') assert await cfg.option('string').value.get() == 'foo' assert not await list_sessions() @pytest.mark.asyncio async def test_mod_read_only_write(): "default with multi is a list" s = StrOption("string", "", default=[], default_multi="string", multi=True) descr = OptionDescription("options", "", [s]) async with await Config(descr) as config: async with await Config(descr) as config2: assert await config.property.getdefault() == {'cache', 'validator', 'warnings'} assert await config.property.getdefault('read_only', 'append') == {'frozen', 'disabled', 'validator', 'everything_frozen', 'mandatory', 'empty', 'force_store_value'} assert await config.property.getdefault('read_only', 'remove') == {'permissive', 'hidden'} assert await config.property.getdefault('read_write', 'append') == {'frozen', 'disabled', 'validator', 'hidden', 'force_store_value'} assert await config.property.getdefault('read_write', 'remove') == {'permissive', 'everything_frozen', 'mandatory', 'empty'} # await config.property.setdefault(frozenset(['cache'])) await config.property.setdefault(type='read_only', when='append', properties=frozenset(['disabled'])) await config.property.setdefault(type='read_only', when='remove', properties=frozenset(['hidden'])) await config.property.setdefault(type='read_write', when='append', properties=frozenset(['disabled', 'hidden'])) await config.property.setdefault(type='read_write', when='remove', properties=frozenset([])) with pytest.raises(ValueError): await config.property.setdefault(type='unknown', when='append', properties=frozenset(['disabled'])) with pytest.raises(ValueError): await config.property.setdefault(type='read_only', when='unknown', properties=frozenset(['disabled'])) with pytest.raises(TypeError): await config.property.setdefault(type='read_only', when='append', properties=['disabled']) assert await config.property.getdefault() == {'cache'} assert await config.property.getdefault('read_only', 'append') == {'disabled'} assert await config.property.getdefault('read_only', 'remove') == {'hidden'} assert await config.property.getdefault('read_write', 'append') == {'disabled', 'hidden'} assert await config.property.getdefault('read_write', 'remove') == set([]) # await config.property.read_only() assert await config.property.get() == {'cache', 'disabled'} await config.property.read_write() assert await config.property.get() == {'cache', 'disabled', 'hidden'} await config.property.read_only() assert await config.property.get() == {'cache', 'disabled'} # assert await config2.property.getdefault() == {'cache', 'validator', 'warnings'} assert await config2.property.getdefault('read_only', 'append') == {'frozen', 'disabled', 'validator', 'everything_frozen', 'mandatory', 'empty', 'force_store_value'} assert await config2.property.getdefault('read_only', 'remove') == {'permissive', 'hidden'} assert await config2.property.getdefault('read_write', 'append') == {'frozen', 'disabled', 'validator', 'hidden', 'force_store_value'} assert await config2.property.getdefault('read_write', 'remove') == {'permissive', 'everything_frozen', 'mandatory', 'empty'} with pytest.raises(ValueError): await config2.property.getdefault('unknown', 'remove') with pytest.raises(ValueError): await config2.property.getdefault('read_write', 'unknown') assert not await list_sessions() @pytest.mark.asyncio async def test_setitem(config_type): s = StrOption("string", "", default=["string", "sdfsdf"], default_multi="prout", multi=True) descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: cfg = await get_config(cfg, config_type) await cfg.option('string').value.set([undefined, 'foo']) assert await cfg.option('string').value.get() == ['string', 'foo'] assert not await list_sessions() @pytest.mark.asyncio async def test_reset(config_type): "if value is None, resets to default owner" s = StrOption("string", "", default="string") descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: cfg = await get_config(cfg, config_type) await cfg.option('string').value.set('foo') assert await cfg.option('string').value.get() == "foo" assert await cfg.option('string').owner.get() ==owners.user await cfg.option('string').value.reset() assert await cfg.option('string').value.get() == 'string' assert await cfg.option('string').owner.get() ==owners.default assert not await list_sessions() @pytest.mark.asyncio async def test_reset_with_multi(config_type): s = StrOption("string", "", default=["string"], default_multi="string", multi=True) descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: cfg = await get_config(cfg, config_type) # await cfg.option('string').value.set([]) await cfg.option('string').value.reset() assert await cfg.option('string').value.get() == ["string"] assert await cfg.option('string').owner.get() =='default' await cfg.option('string').value.set(["eggs", "spam", "foo"]) assert await cfg.option('string').owner.get() =='user' await cfg.option('string').value.set([]) await cfg.option('string').value.reset() # assert await cfg.option('string').value.get() == ["string"] assert await cfg.option('string').owner.get() =='default' with pytest.raises(ValueError): await cfg.option('string').value.set(None) assert not await list_sessions() @pytest.mark.asyncio async def test_property_get_unique_empty(): s = StrOption("string", "", default=["string"], default_multi="string", multi=True) s2 = StrOption("string2", "", default=["string"], default_multi="string", multi=True, properties=('notunique',)) s3 = StrOption("string3", "", default=["string"], default_multi="string", multi=True, properties=('notempty',)) s4 = StrOption("string4", "", default=["string"], default_multi="string", multi=True, properties=('notunique', 'notempty')) descr = OptionDescription("options", "", [s, s2, s3, s4]) async with await Config(descr) as cfg: await cfg.property.read_write() assert await cfg.option('string').property.get() == {'empty', 'unique'} assert await cfg.option('string2').property.get() == {'empty', 'notunique'} assert await cfg.option('string3').property.get() == {'unique', 'notempty'} assert await cfg.option('string4').property.get() == {'notunique', 'notempty'} assert not await list_sessions() @pytest.mark.asyncio async def test_property_only_raises(): s = StrOption("string", "", default=["string"], default_multi="string", multi=True) intoption = IntOption('int', 'Test int option', default=0) hidden_property = Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(intoption), 'expected': ParamValue(1)})) stroption = StrOption('str', 'Test string option', default=["abc"], default_multi="abc", properties=(hidden_property,), multi=True) descr = OptionDescription("options", "", [s, intoption, stroption]) async with await Config(descr) as cfg: await cfg.property.read_write() assert await cfg.option('str').property.get() == {'empty', 'unique'} assert await cfg.option('str').property.get(only_raises=True) == set() assert not await list_sessions() @pytest.mark.asyncio async def test_default_with_multi(): "default with multi is a list" s = StrOption("string", "", default=[], default_multi="string", multi=True) descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: assert await cfg.option('string').value.get() == [] s = StrOption("string", "", default=None, default_multi="string", multi=True) descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: assert await cfg.option('string').value.get() == [] assert not await list_sessions() @pytest.mark.asyncio async def test_idontexist(): descr = make_description() async with await Config(descr) as cfg: await cfg.value.dict() with pytest.raises(AttributeError): await cfg.option('idontexist').value.get() assert not await list_sessions() # ____________________________________________________________ @pytest.mark.asyncio async def test_attribute_access_with_multi(config_type): s = StrOption("string", "", default=["string"], default_multi="string", multi=True) descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: cfg = await get_config(cfg, config_type) await cfg.option('string').value.set(["foo", "bar"]) assert await cfg.option('string').value.get() == ["foo", "bar"] assert not await list_sessions() @pytest.mark.asyncio async def test_item_access_with_multi(config_type): s = StrOption("string", "", default=["string"], multi=True) descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: cfg = await get_config(cfg, config_type) await cfg.option('string').value.set(["foo", "bar"]) assert await cfg.option('string').value.get() == ["foo", "bar"] await cfg.option('string').value.set(["changetest", "bar"]) assert await cfg.option('string').value.get() == ["changetest", "bar"] assert not await list_sessions() @pytest.mark.asyncio async def test_access_with_multi_default(config_type): s = StrOption("string", "", default=["string"], multi=True) descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: cfg = await get_config(cfg, config_type) assert await cfg.option('string').owner.get() =='default' await cfg.option('string').value.set(["foo", "bar"]) assert await cfg.option('string').value.get() == ["foo", "bar"] assert await cfg.option('string').owner.get() =='user' assert not await list_sessions() @pytest.mark.asyncio async def test_multi_with_requires(): s = StrOption("string", "", default=["string"], default_multi="string", multi=True) intoption = IntOption('int', 'Test int option', default=0) hidden_property = Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(intoption), 'expected': ParamValue(1)})) stroption = StrOption('str', 'Test string option', default=["abc"], default_multi="abc", properties=(hidden_property,), multi=True) descr = OptionDescription("options", "", [s, intoption, stroption]) async with await Config(descr) as cfg: await cfg.property.read_write() assert not 'hidden' in await cfg.option('str').property.get() await cfg.option('int').value.set(1) with pytest.raises(PropertiesOptionError): await cfg.option('str').value.set(['a', 'b']) assert 'hidden' in await cfg.forcepermissive.option('str').property.get() assert not await list_sessions() @pytest.mark.asyncio async def test_requires_with_inverted(): s = StrOption("string", "", default=["string"], multi=True) intoption = IntOption('int', 'Test int option', default=0) hide_property = Calculation(calc_value, Params(ParamValue('hide'), kwargs={'condition': ParamOption(intoption), 'expected': ParamValue(1), 'reverse_condition': ParamValue(True)})) stroption = StrOption('str', 'Test string option', default=["abc"], default_multi="abc", properties=(hide_property,), multi=True) descr = OptionDescription("options", "", [s, intoption, stroption]) async with await Config(descr) as cfg: assert not 'hidden' in await cfg.option('str').property.get() assert 'hide' in await cfg.option('str').property.get() await cfg.option('int').value.set(1) assert not 'hidden' in await cfg.option('str').property.get() assert not 'hide' in await cfg.option('str').property.get() assert not await list_sessions() @pytest.mark.asyncio async def test_multi_with_requires_in_another_group(): s = StrOption("string", "", default=["string"], multi=True) intoption = IntOption('int', 'Test int option', default=0) hidden_property = Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(intoption), 'expected': ParamValue(1)})) stroption = StrOption('str', 'Test string option', default=["abc"], properties=(hidden_property,), multi=True) descr = OptionDescription("opt", "", [stroption]) descr2 = OptionDescription("opt2", "", [intoption, s, descr]) async with await Config(descr2) as cfg: await cfg.property.read_write() assert not 'hidden' in await cfg.option('opt.str').property.get() await cfg.option('int').value.set(1) with pytest.raises(PropertiesOptionError): await cfg.option('opt.str').value.set(['a', 'b']) assert 'hidden' in await cfg.forcepermissive.option('opt.str').property.get() assert not await list_sessions() @pytest.mark.asyncio async def test_multi_with_requires_in_another_group_inverse(): s = StrOption("string", "", default=["string"], multi=True) intoption = IntOption('int', 'Test int option', default=0) hidden_property = Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(intoption), 'expected': ParamValue(1)})) # requires=[{'option': intoption, 'expected': 1, 'action': 'hidden'}], multi=True) stroption = StrOption('str', 'Test string option', default=["abc"], properties=(hidden_property,), multi=True) descr = OptionDescription("opt", "", [stroption]) descr2 = OptionDescription("opt2", "", [intoption, s, descr]) async with await Config(descr2) as cfg: await cfg.property.read_write() assert not 'hidden' in await cfg.option('opt.str').property.get() await cfg.option('int').value.set(1) with pytest.raises(PropertiesOptionError): await cfg.option('opt.str').value.set(['a', 'b']) assert 'hidden' in await cfg.forcepermissive.option('opt.str').property.get() assert not await list_sessions() @pytest.mark.asyncio async def test_apply_requires_from_config(): s = StrOption("string", "", default=["string"], multi=True) intoption = IntOption('int', 'Test int option', default=0) hidden_property = Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(intoption), 'expected': ParamValue(1)})) stroption = StrOption('str', 'Test string option', default=["abc"], properties=(hidden_property,), multi=True) descr = OptionDescription("opt", "", [stroption]) descr2 = OptionDescription("opt2", "", [intoption, s, descr]) async with await Config(descr2) as cfg: await cfg.property.read_write() assert not 'hidden' in await cfg.option('opt.str').property.get() await cfg.option('int').value.set(1) with pytest.raises(PropertiesOptionError): await cfg.option('opt.str').value.get() assert 'hidden' in await cfg.forcepermissive.option('opt.str').property.get() assert 'hidden' not in await cfg.forcepermissive.option('opt.str').option.properties() assert 'hidden' not in await cfg.forcepermissive.option('opt.str').option.properties(only_raises=True) assert not await list_sessions() @pytest.mark.asyncio async def test_apply_requires_with_disabled(): s = StrOption("string", "", default=["string"], multi=True) intoption = IntOption('int', 'Test int option', default=0) disabled_property = Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(intoption), 'expected': ParamValue(1)})) stroption = StrOption('str', 'Test string option', default=["abc"], properties=(disabled_property,), multi=True) descr = OptionDescription("opt", "", [stroption]) descr2 = OptionDescription("opt2", "", [intoption, s, descr]) async with await Config(descr2) as cfg: await cfg.property.read_write() assert not 'disabled' in await cfg.option('opt.str').property.get() await cfg.option('int').value.set(1) with pytest.raises(PropertiesOptionError): await cfg.option('opt.str').value.get() assert 'disabled' not in await cfg.unrestraint.option('opt.str').option.properties() assert 'disabled' not in await cfg.unrestraint.option('opt.str').option.properties(only_raises=True) assert 'disabled' in await cfg.unrestraint.option('opt.str').property.get() assert not await list_sessions() @pytest.mark.asyncio async def test_multi_with_requires_with_disabled_in_another_group(): s = StrOption("string", "", default=["string"], multi=True) intoption = IntOption('int', 'Test int option', default=0) disabled_property = Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition': ParamOption(intoption), 'expected': ParamValue(1)})) stroption = StrOption('str', 'Test string option', default=["abc"], properties=(disabled_property,), multi=True) descr = OptionDescription("opt", "", [stroption]) descr2 = OptionDescription("opt2", "", [intoption, s, descr]) async with await Config(descr2) as cfg: await cfg.property.read_write() assert not 'disabled' in await cfg.option('opt.str').property.get() await cfg.option('int').value.set(1) with pytest.raises(PropertiesOptionError): await cfg.option('opt.str').value.set(['a', 'b']) assert 'disabled' in await cfg.unrestraint.option('opt.str').property.get() assert not await list_sessions() # FIXME @pytest.mark.asyncio # FIXME async def test_multi_with_requires_that_is_multi(): # FIXME b = IntOption('int', 'Test int option', default=[0], multi=True) # FIXME hidden_property = Calculation(calc_value, # FIXME Params(ParamValue('hidden'), # FIXME kwargs={'condition': ParamOption(b), # FIXME 'expected': ParamValue(1)})) # FIXME c = StrOption('str', 'Test string option', default=['abc'], properties=(hidden_property,), multi=True) # FIXME descr = OptionDescription("opt", "", [b, c]) # FIXME descr # FIXME # FIXME: ValueError: requirement mal formés pour l'option "int" ne doit pas être une valeur multiple pour "str" # FIXME with pytest.raises(ValueError): # FIXME Config(descr)") # # # FIXME @pytest.mark.asyncio # FIXME async def test_multi_with_requires_that_is_multi_inverse(): # FIXME b = IntOption('int', 'Test int option', default=[0], multi=True) # FIXME c = StrOption('str', 'Test string option', default=['abc'], requires=[{'option': b, 'expected': 0, 'action': 'hidden', 'inverse': True}], multi=True) # FIXME descr = OptionDescription("opt", "", [b, c]) # FIXME descr # FIXME Config(descr) # FIXME # FIXME: ValueError: requirement mal formés pour l'option "int" ne doit pas être une valeur multiple pour "str" # FIXME with pytest.raises(ValueError): # FIXME Config(descr)") # # # FIXME @pytest.mark.asyncio # FIXME async def test_multi_with_requires_that_is_leadership(): # FIXME b = IntOption('int', 'Test int option', default=[0], multi=True) # FIXME c = StrOption('str', 'Test string option', requires=[{'option': b, 'expected': 1, 'action': 'hidden'}], multi=True) # FIXME descr = Leadership("int", "", [b, c]) # FIXME od = OptionDescription('root', '', [descr]) # FIXME Config(od) # # # FIXME @pytest.mark.asyncio # FIXME async def test_multi_with_requires_that_is_leadership_leader(): # FIXME b = IntOption('int', 'Test int option', multi=True) # FIXME c = StrOption('str', 'Test string option', requires=[{'option': b, 'expected': 1, 'action': 'hidden'}], multi=True) # FIXME with pytest.raises(ValueError): # FIXME Leadership('str', '', [c, b])") @pytest.mark.asyncio async def test_multi_with_requires_that_is_leadership_follower(): b = IntOption('int', 'Test int option', default=[0], multi=True) c = StrOption('str', 'Test string option', multi=True) hidden_property = Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(c), 'index': ParamIndex(), 'expected': ParamValue('1')})) d = StrOption('str1', 'Test string option', properties=(hidden_property,), multi=True) descr = Leadership("int", "", [b, c, d]) descr2 = OptionDescription('od', '', [descr]) async with await Config(descr2) as cfg: await cfg.property.read_write() assert await cfg.option('int.int').value.get() == [0] assert await cfg.option('int.str', 0).value.get() == None assert await cfg.option('int.str1', 0).value.get() == None await cfg.option('int.int').value.set([0, 1]) assert await cfg.option('int.int').value.get() == [0, 1] assert await cfg.option('int.str', 0).value.get() == None assert await cfg.option('int.str', 1).value.get() == None assert await cfg.option('int.str1', 0).value.get() == None assert await cfg.option('int.str1', 1).value.get() == None await cfg.option('int.str', 1).value.set('1') await cfg.property.read_only() assert await cfg.option('int.str1', 0).value.get() == None assert await cfg.option('int.str1', 1).value.get() == None await cfg.property.read_write() assert await cfg.option('int.str1', 0).value.get() == None with pytest.raises(PropertiesOptionError): await cfg.option('int.str1', 1).value.get() assert not await list_sessions() @pytest.mark.asyncio async def test_multi_with_requires_that_is_leadership_follower_inverse(): b = IntOption('int', 'Test int option', default=[0], multi=True) c = StrOption('str', 'Test string option', multi=True) hidden_property = Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(c), 'index': ParamIndex(), 'reverse_condition': ParamValue(True), 'expected': ParamValue(None)})) d = StrOption('str1', 'Test string option', properties=(hidden_property,), multi=True) descr = Leadership("int", "", [b, c, d]) descr2 = OptionDescription('od', '', [descr]) async with await Config(descr2) as cfg: await cfg.property.read_write() assert await cfg.option('int.int').value.get() == [0] assert await cfg.option('int.str', 0).value.get() is None assert await cfg.option('int.str1', 0).value.get() is None await cfg.option('int.int').value.set([0, 1]) assert await cfg.option('int.int').value.get() == [0, 1] assert await cfg.option('int.str', 0).value.get() is None assert await cfg.option('int.str', 1).value.get() is None assert await cfg.option('int.str1', 0).value.get() is None assert await cfg.option('int.str1', 1).value.get() is None await cfg.option('int.str', 1).value.set('1') await cfg.property.read_only() assert await cfg.option('int.str1', 0).value.get() is None assert await cfg.option('int.str1', 1).value.get() is None await cfg.property.read_write() assert await cfg.option('int.str1', 0).value.get() is None with pytest.raises(PropertiesOptionError): await cfg.option('int.str1', 1).value.get() assert not await list_sessions() #@pytest.mark.asyncio #async def test_multi_with_requires_that_is_not_same_leadership(): # b = IntOption('int', 'Test int option', default=[0], multi=True) # hidden_property = Calculation(calc_value, # Params(ParamValue('hidden'), # kwargs={'condition': ParamOption(b), # 'index': ParamIndex(), # 'expected': ParamValue(1)})) # c = StrOption('str', 'Test string option', properties=(hidden_property,), multi=True) # #c = StrOption('str', 'Test string option', requires=[{'option': b, 'expected': 1, 'action': 'hidden'}], multi=True) # descr1 = Leadership("int", "", [b, c]) # d = IntOption('int1', 'Test int option', default=[0], multi=True) # e = StrOption('str', 'Test string option', requires=[{'option': b, 'expected': 1, 'action': 'hidden'}], multi=True) # descr2 = Leadership("int1", "", [d, e]) # descr3 = OptionDescription('val', '', [descr1, descr2]) # descr3 # with pytest.raises(ValueError): # Config(descr3)") @pytest.mark.asyncio async def test_multi_with_bool(): s = BoolOption("bool", "", default=[False], multi=True) descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: await cfg.option('bool').value.set([True, False]) assert await cfg.option('bool').value.get() == [True, False] assert not await list_sessions() @pytest.mark.asyncio async def test_choice_access_with_multi(): ch = ChoiceOption("t1", "", ("a", "b"), default=["a"], multi=True, properties=('notunique',)) descr = OptionDescription("options", "", [ch]) async with await Config(descr) as cfg: await cfg.option('t1').value.set(["a", "b", "a", "b"]) assert await cfg.option('t1').value.get() == ["a", "b", "a", "b"] assert not await list_sessions() #____________________________________________________________ @pytest.mark.asyncio async def test_accepts_multiple_changes_from_option(): s = StrOption("string", "", default="string") descr = OptionDescription("options", "", [s]) async with await Config(descr) as cfg: await cfg.option('string').value.set("egg") assert await cfg.option('string').option.default() == "string" assert await cfg.option('string').value.get() == "egg" await cfg.option('string').value.set('blah') assert await cfg.option('string').option.default() == "string" assert await cfg.option('string').value.get() == "blah" await cfg.option('string').value.set('bol') assert await cfg.option('string').value.get() == 'bol' assert not await list_sessions() @pytest.mark.asyncio async def test_allow_multiple_changes_from_config(): """ a `setoption` from the config object is much like the attribute access, except the fact that value owner can bet set """ s = StrOption("string", "", default="string") s2 = StrOption("string2", "", default="string") suboption = OptionDescription("bip", "", [s2]) descr = OptionDescription("options", "", [s, suboption]) async with await Config(descr) as cfg: await cfg.option('string').value.set("oh") assert await cfg.option('string').value.get() == "oh" await cfg.option('string').value.set("blah") assert await cfg.option('string').value.get() == "blah" assert not await list_sessions() # ____________________________________________________________ # accessing a value by the get method @pytest.mark.asyncio async def test_access_by_get(): descr = make_description() async with await Config(descr) as cfg: with pytest.raises(AttributeError): list(await cfg.option.find('idontexist')) ret = await cfg.option.find('wantref', first=True) assert await ret.value.get() is False ret = await cfg.option.find('dummy', first=True) assert await ret.value.get() is False assert not await list_sessions() @pytest.mark.asyncio async def test_access_by_get_whith_hide(): b1 = BoolOption("b1", "", properties=(('hidden'),)) descr = OptionDescription("opt", "", [OptionDescription("sub", "", [b1, ChoiceOption("c1", "", ('a', 'b', 'c'), 'a'), BoolOption("d1", "")]), BoolOption("b2", ""), BoolOption("d1", "")]) async with await Config(descr) as cfg: await cfg.property.read_write() with pytest.raises(AttributeError): ret = await cfg.option.find('b1') await ret.value.get() assert not await list_sessions() @pytest.mark.asyncio async def test_append_properties(): descr = make_description() async with await Config(descr) as cfg: assert await cfg.option('gc.dummy').property.get() == set() await cfg.option('gc.dummy').property.add('test') assert await cfg.option('gc.dummy').property.get() == {'test'} with pytest.raises(ConfigError): await cfg.option('gc.dummy').property.add('force_store_value') assert await cfg.option('gc.dummy').property.get() == {'test'} assert not await list_sessions() @pytest.mark.asyncio async def test_reset_properties(): descr = make_description() async with await Config(descr) as cfg: assert await cfg.option('gc.dummy').property.get() == set() await cfg.option('gc.dummy').property.add('frozen') assert await cfg.option('gc.dummy').property.get() == {'frozen'} await cfg.option('gc.dummy').property.reset() assert await cfg.option('gc.dummy').property.get() == set() assert not await list_sessions() @pytest.mark.asyncio async def test_properties_cached(): b1 = BoolOption("b1", "", properties=('test',)) descr = OptionDescription("opt", "", [OptionDescription("sub", "", [b1])]) async with await Config(descr) as cfg: await cfg.property.read_write() assert await cfg.option('sub.b1').property.get() == {'test'} assert not await list_sessions() @pytest.mark.asyncio async def test_append_properties_force_store_value(): gcdummy = BoolOption('dummy', 'dummy', default=False, properties=('force_store_value',)) gcgroup = OptionDescription('gc', '', [gcdummy]) descr = OptionDescription('tiramisu', '', [gcgroup]) async with await Config(descr) as cfg: assert await cfg.option('gc.dummy').property.get() == {'force_store_value'} await cfg.option('gc.dummy').property.add('test') assert await cfg.option('gc.dummy').property.get() == {'force_store_value', 'test'} assert not await list_sessions() @pytest.mark.asyncio async def test_reset_properties_force_store_value(): gcdummy = BoolOption('dummy', 'dummy', default=False, properties=('force_store_value',)) gcgroup = OptionDescription('gc', '', [gcdummy]) descr = OptionDescription('tiramisu', '', [gcgroup]) async with await Config(descr) as cfg: assert await cfg.property.exportation() == {} await cfg.property.add('frozen') assert await cfg.property.exportation() == \ {None: {None: set(('frozen', 'cache', 'validator', 'warnings'))}} await cfg.property.reset() if environ.get('TIRAMISU_STORAGE') in ['sqlite3', 'postgres']: assert await cfg.property.exportation() == {} else: assert await cfg.property.exportation() == {None: {}} await cfg.option('gc.dummy').property.add('test') if environ.get('TIRAMISU_STORAGE') in ['sqlite3', 'postgres']: assert await cfg.property.exportation() == {'gc.dummy': {None: set(('test', 'force_store_value'))}} else: assert await cfg.property.exportation() == {None: {}, 'gc.dummy': {None: set(('test', 'force_store_value'))}} await cfg.property.reset() if environ.get('TIRAMISU_STORAGE') in ['sqlite3', 'postgres']: assert await cfg.property.exportation() == {'gc.dummy': {None: set(('test', 'force_store_value'))}} else: assert await cfg.property.exportation() == {None: {}, 'gc.dummy': {None: set(('test', 'force_store_value'))}} await cfg.property.add('frozen') assert await cfg.property.exportation() == \ {None: {None: set(('frozen', 'validator', 'cache', 'warnings'))}, 'gc.dummy': {None: set(('test', 'force_store_value'))}} await cfg.property.add('frozen') assert await cfg.property.exportation() == \ {None: {None: set(('frozen', 'validator', 'cache', 'warnings'))}, 'gc.dummy': {None: set(('test', 'force_store_value'))}} await cfg.option('gc.dummy').property.add('test') assert await cfg.property.exportation() == \ {None: {None: set(('frozen', 'validator', 'cache', 'warnings'))}, 'gc.dummy': {None: set(('test', 'force_store_value'))}} assert not await list_sessions() @pytest.mark.asyncio async def test_importation_force_store_value(): gcdummy = BoolOption('dummy', 'dummy', default=False, properties=('force_store_value',)) gcgroup = OptionDescription('gc', '', [gcdummy]) descr = OptionDescription('tiramisu', '', [gcgroup]) async with await Config(descr) as config1: assert await config1.value.exportation() == [[], [], [], []] await config1.property.add('frozen') assert await config1.value.exportation() == [[], [], [], []] await config1.property.add('force_store_value') assert await config1.value.exportation() == [['gc.dummy'], [None], [False], ['forced']] exportation = await config1.property.exportation() async with await Config(descr) as config2: assert await config2.value.exportation() == [[], [], [], []] await config2.property.importation(exportation) assert await config2.value.exportation() == [['gc.dummy'], [None], [False], ['forced']] await config2.property.importation(exportation) assert await config2.value.exportation() == [['gc.dummy'], [None], [False], ['forced']] assert not await list_sessions() @pytest.mark.asyncio async def test_set_modified_value(): gcdummy = BoolOption('dummy', 'dummy', default=False, properties=('force_store_value',)) gcgroup = OptionDescription('gc', '', [gcdummy]) descr = OptionDescription('tiramisu', '', [gcgroup]) async with await Config(descr) as cfg: assert await cfg.property.exportation() == {} await cfg.property.importation({None: {None: set(('frozen', 'cache', 'validator', 'warnings'))}}) assert await cfg.property.exportation() == \ {None: {None: set(('frozen', 'cache', 'validator', 'warnings'))}} assert not await list_sessions() @pytest.mark.asyncio async def test_pprint(): msg_error = _("cannot access to {0} \"{1}\" because has {2} {3}") msg_is_not = _('the value of "{0}" is not {1}') msg_is = _('the value of "{0}" is {1}') properties = _('properties') prop = _('property') s = StrOption("string", "", default=["string"], default_multi="string", multi=True, properties=('hidden', 'disabled')) s2 = StrOption("string2", "", default="string") s3 = StrOption("string3", "", default=["string"], default_multi="string", multi=True, properties=('hidden',)) intoption = IntOption('int', 'Test int option', default=0) hidden_property = Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(intoption, todict=True), 'expected_0': ParamValue(2), 'expected_1': ParamValue(3), 'expected_2': ParamValue(4), 'reverse_condition': ParamValue(True)}), calc_value_property_help) disabled_property = Calculation(calc_value, Params(ParamValue('disabled'), kwargs={'condition_0': ParamOption(intoption, todict=True), 'expected_0': ParamValue(1), 'condition_1': ParamOption(s2, todict=True), 'expected_1': ParamValue('string')}), calc_value_property_help) stroption = StrOption('str', 'Test string option', default="abc", properties=(hidden_property, disabled_property)) # requires=[{'option': intoption, 'expected': 2, 'action': 'hidden', 'inverse': True}, # {'option': intoption, 'expected': 3, 'action': 'hidden', 'inverse': True}, # {'option': intoption, 'expected': 4, 'action': 'hidden', 'inverse': True}, # {'option': intoption, 'expected': 1, 'action': 'disabled'}, # {'option': s2, 'expected': 'string', 'action': 'disabled'}]) val2 = StrOption('val2', "") hidden_property = Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(intoption, todict=True), 'expected': ParamValue(1)}), calc_value_property_help) descr2 = OptionDescription("options", "", [val2], properties=(hidden_property,)) #descr2 = OptionDescription("options", "", [val2], requires=[{'option': intoption, 'expected': 1, 'action': 'hidden'}]) hidden_property = Calculation(calc_value, Params(ParamValue('hidden'), kwargs={'condition': ParamOption(stroption, todict=True), 'expected': ParamValue('2'), 'reverse_condition': ParamValue(True)}), calc_value_property_help) val3 = StrOption('val3', "", properties=(hidden_property,)) #val3 = StrOption('val3', "", requires=[{'option': stroption, 'expected': '2', 'action': 'hidden', 'inverse': True}]) descr = OptionDescription("options", "", [s, s2, s3, intoption, stroption, descr2, val3]) async with await Config(descr) as cfg: await cfg.property.read_write() await cfg.option('int').value.set(1) err = None try: await cfg.option('str').value.get() except PropertiesOptionError as error: err = error list_disabled = '"disabled" (' + display_list([msg_is.format('Test int option', '"1"'), msg_is.format('string2', '"string"')], add_quote=False) + ')' list_hidden = '"hidden" (' + msg_is_not.format('Test int option', display_list([2, 3, 4], 'or', add_quote=True)) + ')' assert str(err) == _(msg_error.format('option', 'Test string option', properties, display_list([list_disabled, list_hidden], add_quote=False))) del err err = None try: await cfg.option('options.val2').value.get() except PropertiesOptionError as error: err = error assert str(err) == msg_error.format('optiondescription', 'options', prop, '"hidden" (' + msg_is.format('Test int option', '"1"') + ')') #err = None #try: # await cfg.option('val3').value.get() #except PropertiesOptionError as error: # err = error #msg_1 = msg_is.format('string2', 'string') #msg_2 = msg_is.format('Test int option', 1) #msg_3 = msg_is_not.format('Test int option', display_list([2, 3, 4], 'or', add_quote=True)) #list_hidden = '"hidden" (' + display_list([msg_2, msg_3, msg_1]) + ')' #assert str(err) == msg_error.format('option', 'val3', prop, list_hidden) err = None try: await cfg.option('string').value.get() except Exception as error: err = error assert str(err) == msg_error.format('option', 'string', properties, display_list(['disabled', 'hidden'], add_quote=True)) del err err = None try: await cfg.option('string3').value.get() except Exception as error: err = error assert str(err) == msg_error.format('option', 'string3', prop, '"hidden"') del err assert not await list_sessions()