tiramisu/tests/test_freeze.py

# coding: utf-8
"frozen and hidden values"
from .autopath import do_autopath
do_autopath()

import pytest

from tiramisu.setting import owners, groups
from tiramisu import ChoiceOption, BoolOption, IntOption, FloatOption, \
    StrOption, OptionDescription, SymLinkOption, Leadership, Config, \
    Calculation, Params, ParamOption, ParamValue, calc_value
from tiramisu.error import PropertiesOptionError, ConfigError
from tiramisu.storage import list_sessions


def teardown_function(function):
    assert list_sessions() == [], 'session list is not empty when leaving "{}"'.format(function.__name__)


def compare(calculated, expected):
    def convert_list(val):
        if isinstance(val, list):
            val = tuple(val)
        return val
    # convert to tuple
    for idx in range(len(calculated[0])):
        right_idx = expected[0].index(calculated[0][idx])
        for typ in range(4):
            assert convert_list(calculated[typ][idx]) == expected[typ][right_idx]


#____________________________________________________________
#freeze
def make_description_freeze():
    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], multi=True)
    hidden_property = Calculation(calc_value,
                                  Params(ParamValue('hidden'),
                                         kwargs={'condition': ParamOption(booloption, raisepropertyerror=True),
                                                 'expected': ParamValue(True),
                                                 'default': ParamValue(None)}))
    wantref_option = BoolOption('wantref', 'Test requires', default=False, properties=('force_store_value', hidden_property))
    wantref2_option = BoolOption('wantref2', 'Test requires', default=False, properties=('force_store_value', 'hidden'))
    wantref3_option = BoolOption('wantref3', 'Test requires', default=[False], multi=True, properties=('force_store_value',))
    st2 = SymLinkOption('st2', wantref3_option)
    hidden_property = Calculation(calc_value,
                                  Params(ParamValue('hidden'),
                                         kwargs={'condition': ParamOption(booloption, raisepropertyerror=True),
                                                 'expected': ParamValue(True),
                                                 'default': ParamValue(None)}))
    wantframework_option = BoolOption('wantframework', 'Test requires',
                                      default=False,
                                      properties=(hidden_property,))

    gcgroup = OptionDescription('gc', '', [gcoption, gcdummy, floatoption])
    descr = OptionDescription('tiramisu', '', [gcgroup, booloption, objspaceoption,
                              wantref_option, wantref2_option, wantref3_option, st2, stroption,
                              wantframework_option,
                              intoption, boolop])
    return descr


def return_val():
    return 1


def return_val2(value):
    return value


def return_val3(context, value):
    return value


@pytest.mark.asyncio
async def test_freeze_whole_config():
    descr = make_description_freeze()
    cfg = await Config(descr)
    await cfg.property.read_write()
    await cfg.property.add('everything_frozen')
    assert await cfg.option('gc.dummy').value.get() is False
    prop = []
    try:
        await cfg.option('gc.dummy').value.set(True)
    except PropertiesOptionError as err:
        prop = err.proptype
    assert 'frozen' in prop
    assert await cfg.option('gc.dummy').value.get() is False
    #
    await cfg.property.pop('everything_frozen')
    await cfg.option('gc.dummy').value.set(True)
    assert await cfg.option('gc.dummy').value.get() is True
    #
    await cfg.property.add('everything_frozen')
    owners.addowner("everythingfrozen2")
    prop = []
    try:
        await cfg.option('gc.dummy').owner.set('everythingfrozen2')
    except PropertiesOptionError as err:
        prop = err.proptype
    assert 'frozen' in prop


@pytest.mark.asyncio
async def test_freeze_one_option():
    "freeze an option "
    descr = make_description_freeze()
    cfg = await Config(descr)
    await cfg.property.read_write()
    #freeze only one option
    await cfg.option('gc.dummy').property.add('frozen')
    assert await cfg.option('gc.dummy').value.get() is False
    prop = []
    try:
        await cfg.option('gc.dummy').value.set(True)
    except PropertiesOptionError as err:
        prop = err.proptype
    assert 'frozen' in prop


@pytest.mark.asyncio
async def test_frozen_value():
    "setattr a frozen value at the config level"
    s = StrOption("string", "", default="string")
    descr = OptionDescription("options", "", [s])
    cfg = await Config(descr)
    await cfg.property.read_write()
    await cfg.property.add('frozen')
    await cfg.option('string').property.add('frozen')
    prop = []
    try:
        await cfg.option('string').value.set('egg')
    except PropertiesOptionError as err:
        prop = err.proptype
    assert 'frozen' in prop


@pytest.mark.asyncio
async def test_freeze():
    "freeze a whole configuration object"
    descr = make_description_freeze()
    cfg = await Config(descr)
    await cfg.property.read_write()
    await cfg.property.add('frozen')
    await cfg.option('gc.name').property.add('frozen')
    prop = []
    try:
        await cfg.option('gc.name').value.set('framework')
    except PropertiesOptionError as err:
        prop = err.proptype
    assert 'frozen' in prop


@pytest.mark.asyncio
async def test_freeze_multi():
    descr = make_description_freeze()
    cfg = await Config(descr)
    await cfg.property.read_write()
    await cfg.property.add('frozen')
    await cfg.option('boolop').property.add('frozen')
    prop = []
    try:
        await cfg.option('boolop').value.set([True])
    except PropertiesOptionError as err:
        prop = err.proptype
    assert 'frozen' in prop


@pytest.mark.asyncio
async def test_force_store_value():
    descr = make_description_freeze()
    cfg = await Config(descr)
    compare(await cfg.value.exportation(), (('wantref', 'wantref2', 'wantref3'), (None, None, None), (False, False, (False,)), ('forced', 'forced', 'forced')))
    await cfg.option('wantref').value.set(True)
    compare(await cfg.value.exportation(), (('wantref', 'wantref2', 'wantref3'), (None, None, None), (True, False, (False,)), ('user', 'forced', 'forced')))
    await cfg.option('wantref').value.reset()
    compare(await cfg.value.exportation(), (('wantref', 'wantref2', 'wantref3'), (None, None, None), (False, False, (False,)), ('forced', 'forced', 'forced')))


@pytest.mark.asyncio
async def test_force_store_value_leadership_follower():
    b = IntOption('int', 'Test int option', multi=True)
    c = StrOption('str', 'Test string option', multi=True, properties=('force_store_value',))
    descr = Leadership("int", "", [b, c])
    with pytest.raises(ConfigError): 
        cfg = await Config(descr)


#@pytest.mark.asyncio
#async def test_force_store_value_leadership():
#    b = IntOption('int', 'Test int option', multi=True, properties=('force_store_value',))
#    c = StrOption('str', 'Test string option', multi=True)
#    descr = Leadership("int", "", [b, c])
#    cfg = await Config(descr)
#    assert await cfg.value.get() == {'int': ('forced', ())}


@pytest.mark.asyncio
async def test_force_store_value_leadership_sub():
    b = IntOption('int', 'Test int option', multi=True, properties=('force_store_value',))
    c = StrOption('str', 'Test string option', multi=True)
    descr = Leadership("int", "", [b, c])
    odr = OptionDescription('odr', '', [descr])
    cfg = await Config(odr)
    compare(await cfg.value.exportation(), (('int.int',), (None,), (tuple(),), ('forced',)))


@pytest.mark.asyncio
async def test_force_store_value_callback():
    b = IntOption('int', 'Test int option', Calculation(return_val), properties=('force_store_value',))
    descr = OptionDescription("int", "", [b])
    cfg = await Config(descr)
    compare(await cfg.value.exportation(), (('int',), (None,), (1,), ('forced',)))


@pytest.mark.asyncio
async def test_force_store_value_callback_params():
    b = IntOption('int', 'Test int option', Calculation(return_val2, Params(kwargs={'value': ParamValue(2)})), properties=('force_store_value',))
    descr = OptionDescription("int", "", [b])
    cfg = await Config(descr)
    compare(await cfg.value.exportation(), (('int',), (None,), (2,), ('forced',)))


@pytest.mark.asyncio
async def test_force_store_value_callback_params_with_opt():
    a = IntOption('val1', "", 2)
    b = IntOption('int', 'Test int option', Calculation(return_val2, Params(kwargs={'value': ParamOption(a)})), properties=('force_store_value',))
    descr = OptionDescription("int", "", [a, b])
    cfg = await Config(descr)
    compare(await cfg.value.exportation(), (('int',), (None,), (2,), ('forced',)))