|
|
import pytest
|
|
|
import os
|
|
|
from calculate.vars.datavars import Namespace, Variable, CyclicVariableError,\
|
|
|
VariableError, ReadonlyVariable,\
|
|
|
ChoiceVariable, IntegerVariable,\
|
|
|
StringVariable, DefaultValue,\
|
|
|
TableVariable, HashVariable,\
|
|
|
VariableNotFoundError
|
|
|
from calculate.vars.vars_loader import NamespaceIniFiller, VariableLoader,\
|
|
|
ProfileFiller, NamespaceIniFillerStrict
|
|
|
|
|
|
|
|
|
@pytest.mark.vars
|
|
|
class TestNamespace:
|
|
|
def test_init_empty_namespace(self):
|
|
|
ns = Namespace()
|
|
|
assert ns.childs == {}
|
|
|
assert ns.variables == {}
|
|
|
|
|
|
def test_create_variable(self):
|
|
|
ns = Namespace()
|
|
|
ns.addStringVariable("test", "12345")
|
|
|
assert ns.test.getValue() == "12345"
|
|
|
ns.addStringVariable("zxcv", "23456")
|
|
|
assert ns.zxcv.getValue() == "23456"
|
|
|
|
|
|
def test_create_ns_with_vars(self):
|
|
|
ns = Namespace()
|
|
|
ns.addNamespace(Namespace("os"))
|
|
|
ns.os.addStringVariable("test", "123")
|
|
|
ns.os.addNamespace(Namespace("linux"))
|
|
|
ns.os.linux.addStringVariable("shortname", "CLD")
|
|
|
assert ns.os.test.getValue() == "123"
|
|
|
assert ns.os["test"].getValue() == "123"
|
|
|
assert ns.os.linux.shortname.getValue() == "CLD"
|
|
|
assert ns.os.root == ns
|
|
|
|
|
|
def test_fill_namespace_simple(self):
|
|
|
ns = Namespace()
|
|
|
nsif = NamespaceIniFiller()
|
|
|
nsif.fill(ns, """
|
|
|
[os]
|
|
|
test = 123
|
|
|
|
|
|
[os][linux]
|
|
|
shortname = CLD
|
|
|
fullname = Calculate Linux Desktop
|
|
|
""")
|
|
|
|
|
|
assert ns.os.test.getValue() == "123"
|
|
|
assert ns.os.linux.shortname.getValue() == "CLD"
|
|
|
assert ns.os.linux.fullname.getValue() == "Calculate Linux Desktop"
|
|
|
assert ns.os.linux.root == ns
|
|
|
|
|
|
nsif.fill(ns, """
|
|
|
[os][linux]
|
|
|
shortname = CLDX
|
|
|
""")
|
|
|
|
|
|
assert ns.os.linux.shortname.getValue() == "CLDX"
|
|
|
assert ns.os.linux.fullname.getValue() == "Calculate Linux Desktop"
|
|
|
|
|
|
def test_fill_namespace_append_and_remove(self):
|
|
|
ns = Namespace()
|
|
|
nsif = NamespaceIniFiller()
|
|
|
nsif.fill(ns, """
|
|
|
[os]
|
|
|
test = 123
|
|
|
|
|
|
[os]
|
|
|
test += 345
|
|
|
""")
|
|
|
|
|
|
assert ns.os.test.getValue() == "123,345"
|
|
|
|
|
|
nsif.fill(ns, """
|
|
|
[os]
|
|
|
test -= 123
|
|
|
""")
|
|
|
|
|
|
assert ns.os.test.getValue() == "345"
|
|
|
|
|
|
nsif.fill(ns, """
|
|
|
[os]
|
|
|
test += asdf,qwer,zxcv
|
|
|
""")
|
|
|
|
|
|
assert ns.os.test.getValue() == "345,asdf,qwer,zxcv"
|
|
|
|
|
|
nsif.fill(ns, """
|
|
|
[os]
|
|
|
test -= asdf,zxcv
|
|
|
""")
|
|
|
|
|
|
assert ns.os.test.getValue() == "345,qwer"
|
|
|
|
|
|
def test_fill_namespace_clear_namespaces(self):
|
|
|
ns = Namespace()
|
|
|
nsif = NamespaceIniFiller()
|
|
|
nsif.fill(ns, """
|
|
|
[test][0]
|
|
|
dev = /dev/sda1
|
|
|
mount = swap
|
|
|
|
|
|
[test][1]
|
|
|
dev = /dev/sda2
|
|
|
mount = /
|
|
|
|
|
|
[test][2]
|
|
|
dev = /dev/sda5
|
|
|
mount = /var/calculate
|
|
|
""")
|
|
|
|
|
|
assert [x.dev.getValue() for x in ns.test] == ['/dev/sda1',
|
|
|
'/dev/sda2',
|
|
|
'/dev/sda5']
|
|
|
|
|
|
nsif.fill(ns, """
|
|
|
[test][0]
|
|
|
dev = /dev/sdb1
|
|
|
mount = swap
|
|
|
|
|
|
[test][1]
|
|
|
dev = /dev/sdb2
|
|
|
mount = /
|
|
|
""")
|
|
|
|
|
|
assert [x.dev.getValue() for x in ns.test] == ['/dev/sdb1',
|
|
|
'/dev/sdb2',
|
|
|
'/dev/sda5']
|
|
|
|
|
|
nsif.fill(ns, """
|
|
|
[test][]
|
|
|
|
|
|
[test][0]
|
|
|
dev = /dev/sdb1
|
|
|
mount = swap
|
|
|
|
|
|
[test][1]
|
|
|
dev = /dev/sdb2
|
|
|
mount = /
|
|
|
""")
|
|
|
|
|
|
assert [x.dev.getValue() for x in ns.test] == ['/dev/sdb1',
|
|
|
'/dev/sdb2']
|
|
|
|
|
|
def test_fill_namespace_strict_clear(self):
|
|
|
ns = Namespace()
|
|
|
nsif = NamespaceIniFiller()
|
|
|
nsif.fill(ns, """
|
|
|
[os][test][0]
|
|
|
dev = /dev/sda1
|
|
|
mount = swap
|
|
|
|
|
|
[os][test][1]
|
|
|
dev = /dev/sda2
|
|
|
mount = /
|
|
|
|
|
|
[os][test][2]
|
|
|
dev = /dev/sda5
|
|
|
mount = /var/calculate
|
|
|
|
|
|
[custom][test]
|
|
|
zxcv = 1
|
|
|
|
|
|
[custom][test2]
|
|
|
zxcv = 2
|
|
|
""")
|
|
|
|
|
|
assert ns.custom.test.zxcv.getValue() == "1"
|
|
|
assert ns.custom.test2.zxcv.getValue() == "2"
|
|
|
|
|
|
nsifs = NamespaceIniFillerStrict()
|
|
|
nsifs.fill(ns, """
|
|
|
[os][test][]
|
|
|
|
|
|
[custom][]
|
|
|
""")
|
|
|
|
|
|
assert [x for x in ns.custom] == []
|
|
|
|
|
|
def test_get_namespace_attrs(self):
|
|
|
ns = Namespace()
|
|
|
os = Namespace("os")
|
|
|
os.addStringVariable("test", "zxcv")
|
|
|
ns.addNamespace(os)
|
|
|
|
|
|
assert ns.os.test.getValue() == "zxcv"
|
|
|
assert ns.os["test"].getValue() == "zxcv"
|
|
|
assert "test" in ns.os
|
|
|
ns.os.test.setValue("123")
|
|
|
assert ns.os.test.getValue() == "123"
|
|
|
ns.os["test"].setValue("234")
|
|
|
assert ns.os.test.getValue() == "234"
|
|
|
|
|
|
def test_variable_get_value(self):
|
|
|
class TestVar(Variable):
|
|
|
def get(self):
|
|
|
return "A"
|
|
|
|
|
|
var = TestVar("test")
|
|
|
|
|
|
assert var.getValue() == "A"
|
|
|
|
|
|
def test_namespace_lookup(self):
|
|
|
ns = Namespace()
|
|
|
os = Namespace("os")
|
|
|
device = Namespace("device")
|
|
|
linux = Namespace("linux")
|
|
|
ns.addNamespace(os)
|
|
|
os.addNamespace(linux)
|
|
|
os.addNamespace(device)
|
|
|
device1 = device.addNamespace()
|
|
|
device1.addStringVariable("dev", "/dev/sda")
|
|
|
device2 = device.addNamespace()
|
|
|
device2.addStringVariable("dev", "/dev/sdb")
|
|
|
device3 = device.addNamespace()
|
|
|
device3.addStringVariable("dev", "/dev/sdc")
|
|
|
|
|
|
ns.addStringVariable("first", "first")
|
|
|
os.addStringVariable("second", "second")
|
|
|
linux.addStringVariable("third", "third")
|
|
|
|
|
|
assert ns.first.getValue() == "first"
|
|
|
assert ns.root.os.second.getValue() == "second"
|
|
|
assert ns.os.second.getValue() == "second"
|
|
|
assert os.root.os.second.getValue() == "second"
|
|
|
assert os.second.getValue() == "second"
|
|
|
assert linux.third.getValue() == "third"
|
|
|
assert linux.root.os.second.getValue() == "second"
|
|
|
|
|
|
with pytest.raises(VariableNotFoundError):
|
|
|
os.third
|
|
|
|
|
|
assert ns.os.device[0].dev.getValue() == "/dev/sda"
|
|
|
assert ns.os.device["0"].dev.getValue() == "/dev/sda"
|
|
|
assert ns.os.device[1].dev.getValue() == "/dev/sdb"
|
|
|
assert ns.os.device[2].dev.getValue() == "/dev/sdc"
|
|
|
|
|
|
assert ns.os.device.parent.second.getValue() == "second"
|
|
|
assert ns.os.device.parent.parent.os.second.getValue() == "second"
|
|
|
assert ns.os.device.parent.parent.parent.os.second.\
|
|
|
getValue() == "second"
|
|
|
|
|
|
def test_variable_get_value_by_variable(self):
|
|
|
class TestVar1(Variable):
|
|
|
def get(self):
|
|
|
return "%s,B" % self.vars.test2.getValue(self)
|
|
|
|
|
|
class TestVar2(Variable):
|
|
|
def get(self):
|
|
|
return "A"
|
|
|
|
|
|
ns = Namespace()
|
|
|
ns.addVariable(TestVar1("test1"))
|
|
|
ns.addVariable(TestVar2("test2"))
|
|
|
|
|
|
assert ns.test1.getValue() == "A,B"
|
|
|
|
|
|
def test_variable_get_value_by_changed_variable(self):
|
|
|
class TestVar1(Variable):
|
|
|
counter = 0
|
|
|
|
|
|
def get(self):
|
|
|
self.counter += 1
|
|
|
return "%s,B" % self.vars.test2.getValue(self)
|
|
|
|
|
|
ns = Namespace()
|
|
|
test1 = TestVar1("test1")
|
|
|
ns.addVariable(test1)
|
|
|
ns.addStringVariable("test2", "A")
|
|
|
|
|
|
assert ns.test1.getValue() == "A,B"
|
|
|
|
|
|
assert test1.counter == 1
|
|
|
# test for get cached variable value
|
|
|
assert ns.test1.getValue() == "A,B"
|
|
|
assert test1.counter == 1
|
|
|
|
|
|
# change value of test2 for recalculate test1
|
|
|
ns.test2.setValue("C")
|
|
|
assert ns.test1.getValue() == "C,B"
|
|
|
assert test1.counter == 2
|
|
|
|
|
|
# change value of test2 for recalculate test1
|
|
|
ns.test2.setValue("D")
|
|
|
assert ns.test1.getValue() == "D,B"
|
|
|
assert test1.counter == 3
|
|
|
|
|
|
def test_cyclic_variable(self):
|
|
|
class TestVar1(Variable):
|
|
|
def get(self):
|
|
|
return "%s,test1" % self.vars.test2.getValue(self)
|
|
|
|
|
|
class TestVar2(Variable):
|
|
|
def get(self):
|
|
|
return "%s,test2" % self.vars.test3.getValue(self)
|
|
|
|
|
|
class TestVar3(Variable):
|
|
|
def get(self):
|
|
|
return "%s,test3" % self.vars.test1.getValue(self)
|
|
|
|
|
|
test1 = TestVar1("test1")
|
|
|
test2 = TestVar2("test2")
|
|
|
test3 = TestVar3("test3")
|
|
|
|
|
|
ns = Namespace()
|
|
|
ns.addVariable(test1)
|
|
|
ns.addVariable(test2)
|
|
|
ns.addVariable(test3)
|
|
|
|
|
|
with pytest.raises(CyclicVariableError) as e:
|
|
|
ns.test1.getValue()
|
|
|
|
|
|
assert e.value.queue[:-1] == ("test1", "test2", "test3")
|
|
|
|
|
|
with pytest.raises(VariableError) as e:
|
|
|
ns.test1.getValue()
|
|
|
|
|
|
def test_drop_invalidate_after_set_value(self):
|
|
|
class TestVar1(Variable):
|
|
|
counter = 0
|
|
|
|
|
|
def get(self):
|
|
|
self.counter += 1
|
|
|
return "%s,test1" % self.vars.test2.getValue(self)
|
|
|
|
|
|
class TestVar2(Variable):
|
|
|
def get(self):
|
|
|
return "ZZZZ"
|
|
|
|
|
|
test1 = TestVar1("test1")
|
|
|
test2 = TestVar2("test2")
|
|
|
ns = Namespace()
|
|
|
ns.addVariable(test1)
|
|
|
ns.addVariable(test2)
|
|
|
|
|
|
assert test1.getValue() == "ZZZZ,test1"
|
|
|
|
|
|
test1.setValue("VVVV")
|
|
|
|
|
|
assert test1.getValue() == "VVVV"
|
|
|
assert test1.counter == 1
|
|
|
|
|
|
test2.setValue("XXXX")
|
|
|
|
|
|
assert test1.getValue() == "VVVV"
|
|
|
assert test1.counter == 1
|
|
|
|
|
|
test1.invalidate()
|
|
|
|
|
|
assert test1.getValue() == "XXXX,test1"
|
|
|
assert test1.counter == 2
|
|
|
|
|
|
def test_change_invalidator_variable(self):
|
|
|
class VarTest(Variable):
|
|
|
counter = 0
|
|
|
|
|
|
def get(self):
|
|
|
self.counter += 1
|
|
|
|
|
|
if self.vars.ifvar.getValue(self):
|
|
|
return "%s,test1" % self.vars.vara.getValue(self)
|
|
|
else:
|
|
|
return "%s,test1" % self.vars.varb.getValue(self)
|
|
|
|
|
|
vartest = VarTest("vartest")
|
|
|
ns = Namespace()
|
|
|
ns.addVariable(vartest)
|
|
|
ns.addStringVariable("vara", "vara")
|
|
|
ns.addStringVariable("varb", "varb")
|
|
|
ns.addStringVariable("ifvar", "true")
|
|
|
|
|
|
assert vartest.getValue() == "vara,test1"
|
|
|
assert vartest.counter == 1
|
|
|
|
|
|
ns.vara.setValue("varc")
|
|
|
assert vartest.getValue() == "varc,test1"
|
|
|
assert vartest.counter == 2
|
|
|
|
|
|
ns.ifvar.setValue("")
|
|
|
assert vartest.getValue() == "varb,test1"
|
|
|
assert vartest.counter == 3
|
|
|
|
|
|
ns.vara.setValue("vard")
|
|
|
assert vartest.getValue() == "varb,test1"
|
|
|
assert vartest.counter == 3
|
|
|
|
|
|
def test_readonly_varaible(self):
|
|
|
class TestVar1(Variable):
|
|
|
properties = [ReadonlyVariable, StringVariable]
|
|
|
|
|
|
def get(self):
|
|
|
return "test1"
|
|
|
|
|
|
test1 = TestVar1("test1")
|
|
|
assert test1.getValue() == "test1"
|
|
|
|
|
|
with pytest.raises(VariableError):
|
|
|
test1.setValue("test2")
|
|
|
|
|
|
assert test1.getValue() == "test1"
|
|
|
test1.setValue("test2", force=True)
|
|
|
assert test1.getValue() == "test2"
|
|
|
|
|
|
def test_choice_variable(self):
|
|
|
class TestVar1(Variable):
|
|
|
properties = [ChoiceVariable]
|
|
|
|
|
|
def choice(self):
|
|
|
return ["test1", "test2"]
|
|
|
|
|
|
test1 = TestVar1("test1")
|
|
|
with pytest.raises(VariableError):
|
|
|
test1.setValue("test3")
|
|
|
test1.setValue("test2")
|
|
|
assert test1.getValue() == "test2"
|
|
|
|
|
|
def test_integer_variable(self):
|
|
|
class TestVar1(Variable):
|
|
|
properties = [IntegerVariable]
|
|
|
|
|
|
test1 = TestVar1("test1")
|
|
|
with pytest.raises(VariableError):
|
|
|
test1.setValue("test3")
|
|
|
test1.setValue("33")
|
|
|
assert test1.getValue() == 33
|
|
|
test1.setValue("-33")
|
|
|
assert test1.getValue() == -33
|
|
|
|
|
|
def test_default_value_property(self):
|
|
|
class TestVar1(Variable):
|
|
|
def get(self):
|
|
|
return "123"
|
|
|
|
|
|
test1 = TestVar1("test1")
|
|
|
assert test1.getValue() == "123"
|
|
|
|
|
|
test1.setValue("987")
|
|
|
test1.addProperty(DefaultValue("567"))
|
|
|
|
|
|
assert test1.getValue() == "987"
|
|
|
test1.invalidate()
|
|
|
assert test1.getValue() == "567"
|
|
|
|
|
|
def test_get_comment(self):
|
|
|
class TestVar1(Variable):
|
|
|
def get(self):
|
|
|
return "123"
|
|
|
|
|
|
class TestVar2(Variable):
|
|
|
def get(self):
|
|
|
return "234"
|
|
|
|
|
|
def getComment(self):
|
|
|
return "[%s]" % self.getValue()
|
|
|
|
|
|
class TestVar3(Variable):
|
|
|
def get(self):
|
|
|
return "ZXC %s" % self.vars.test2.getCommentValue(self)
|
|
|
|
|
|
ns = Namespace()
|
|
|
test1 = TestVar1("test1")
|
|
|
assert test1.getValue() == "123"
|
|
|
assert test1.getComment() == "123"
|
|
|
|
|
|
test2 = TestVar2("test2")
|
|
|
assert test2.getValue() == "234"
|
|
|
assert test2.getComment() == "[234]"
|
|
|
|
|
|
test3 = TestVar3("test3")
|
|
|
ns.addVariable(test1)
|
|
|
ns.addVariable(test2)
|
|
|
ns.addVariable(test3)
|
|
|
|
|
|
assert test3.getValue() == "ZXC [234]"
|
|
|
test2.setValue("567")
|
|
|
assert test3.getValue() == "ZXC [567]"
|
|
|
|
|
|
def test_wrong_choice_varaible(self):
|
|
|
class TestVar1(Variable):
|
|
|
properties = [ChoiceVariable]
|
|
|
|
|
|
class TestVar2(Variable):
|
|
|
properties = [ChoiceVariable]
|
|
|
|
|
|
def choice(self):
|
|
|
return ["test1", "test2"]
|
|
|
|
|
|
class TestVar3(Variable):
|
|
|
properties = [ChoiceVariable]
|
|
|
|
|
|
def choiceComment(self):
|
|
|
return [("test1", "Test1"),
|
|
|
("test2", "Test2")]
|
|
|
|
|
|
test1 = TestVar1("test1")
|
|
|
test2 = TestVar2("test2")
|
|
|
test3 = TestVar3("test3")
|
|
|
|
|
|
with pytest.raises(VariableError):
|
|
|
test1.choice()
|
|
|
|
|
|
with pytest.raises(VariableError):
|
|
|
test1.choiceComment()
|
|
|
|
|
|
assert test2.choice() == ["test1", "test2"]
|
|
|
assert test2.choiceComment() == [("test1", "test1"),
|
|
|
("test2", "test2")]
|
|
|
|
|
|
assert test3.choice() == ["test1", "test2"]
|
|
|
assert test3.choiceComment() == [("test1", "Test1"),
|
|
|
("test2", "Test2")]
|
|
|
|
|
|
def test_loading_test_variable_module(self):
|
|
|
ns = Namespace()
|
|
|
vl = VariableLoader()
|
|
|
vl.fill(ns, "tests/vars/variables", "testvars")
|
|
|
|
|
|
assert ns.level.simple.getValue() == "simple value"
|
|
|
assert ns.level.uselocalsimple.getValue() == "Using simple value"
|
|
|
assert ns.level.usefullsimple.getValue() == "Using simple value"
|
|
|
|
|
|
with pytest.raises(VariableError):
|
|
|
ns.level.badchoice.choice()
|
|
|
|
|
|
with pytest.raises(VariableError):
|
|
|
ns.level.badchoice.choiceComment()
|
|
|
|
|
|
assert ns.level.simple_choice.choice() == ["/dev/sda1",
|
|
|
"/dev/sda2",
|
|
|
"/dev/sda3"]
|
|
|
assert ns.level.comment_choice.choice() == ["/dev/sda1",
|
|
|
"/dev/sda2",
|
|
|
"/dev/sda3"]
|
|
|
assert ns.level.comment_choice.choiceComment() == [
|
|
|
("/dev/sda1", "SWAP"),
|
|
|
("/dev/sda2", "ROOT"),
|
|
|
("/dev/sda3", "DATA")]
|
|
|
|
|
|
ns.level.disks.setValue(["/dev/sda2", "/dev/sda1"])
|
|
|
|
|
|
assert ns.level.disks.getValue() == ["/dev/sda2", "/dev/sda1"]
|
|
|
|
|
|
assert ns.level.comment_choice.choice() == ["/dev/sda2", "/dev/sda1"]
|
|
|
assert ns.level.comment_choice.choiceComment() == [
|
|
|
("/dev/sda2", "ROOT"),
|
|
|
("/dev/sda1", "SWAP")]
|
|
|
|
|
|
assert ns.level is not ns.level.level2.root
|
|
|
assert ns is ns.level.level2.root
|
|
|
assert ns.level.level2.vargetter.getValue() == "/ test"
|
|
|
|
|
|
def test_hash_variable(self):
|
|
|
# hash variable
|
|
|
ns = Namespace()
|
|
|
vl = VariableLoader()
|
|
|
vl.fill(ns, "tests/vars/variables", "testvars")
|
|
|
|
|
|
assert ns.level.linux.getFullname() == "level.linux"
|
|
|
assert ns.level.linux.ver.fullname == "level.linux.ver"
|
|
|
|
|
|
assert ns.level.linux.ver.getValue() == "1.0"
|
|
|
assert ns.level.linux.shortname.getValue() == "CLD"
|
|
|
|
|
|
# проверка обновления значения hash переменной при обновлении
|
|
|
# значения у зависимой перемнной
|
|
|
ns.level.version.setValue("2.0")
|
|
|
assert ns.level.linux.ver.getValue() == "2.0"
|
|
|
|
|
|
# проверка установки значения hash переменной
|
|
|
ns.level.linux.ver.setValue("3.0")
|
|
|
assert ns.level.linux.ver.getValue() == "3.0"
|
|
|
|
|
|
# после установки хотя бы одного значения в hash переменной
|
|
|
# обновление остальных прекращаются до инвалидации (так как
|
|
|
# значения рассматриваются комплексно)
|
|
|
ns.level.myshortname.setValue("CLDG")
|
|
|
assert ns.level.linux.shortname.getValue() == "CLD"
|
|
|
|
|
|
# проверка попытки изменить readonly переменную
|
|
|
with pytest.raises(VariableError):
|
|
|
ns.level.linux.shortname.setValue("CLDX")
|
|
|
|
|
|
# проверка сбора значения hash перемнной
|
|
|
ns.level.linux.invalidate()
|
|
|
assert ns.level.linux.ver.getValue() == "2.0"
|
|
|
assert ns.level.linux.shortname.getValue() == "CLDG"
|
|
|
|
|
|
assert ns.level.linux.test.getValue() == "my test - 2.0"
|
|
|
|
|
|
# проверка обновления значения переменной, используеющей одно
|
|
|
# из значений hash переменной
|
|
|
assert ns.level.shortname_test.getValue() == "CLDG test"
|
|
|
ns.level.linux.shortname.setValue("CLDX", force=True)
|
|
|
assert ns.level.shortname_test.getValue() == "CLDX test"
|
|
|
|
|
|
def test_table_variable(self):
|
|
|
# table variable
|
|
|
ns = Namespace()
|
|
|
vl = VariableLoader()
|
|
|
vl.fill(ns, "tests/vars/variables", "testvars")
|
|
|
|
|
|
assert ns.level.device[0].dev.getValue() == "/dev/sda"
|
|
|
assert ns.level.device[1].dev.getValue() == "/dev/sdb"
|
|
|
assert ns.level.device.getValue() == [{"dev": "/dev/sda",
|
|
|
"type": "hdd",
|
|
|
"name": "Samsung SSD"},
|
|
|
{"dev": "/dev/sdb",
|
|
|
"type": "flash",
|
|
|
"name": "Transcend 64GB"}]
|
|
|
assert ns.level.device[1].type.getValue() == "flash"
|
|
|
|
|
|
# проверка обновления списка пространства имён у табличной переменной
|
|
|
ns.level.devicelist.setValue(["/dev/sda", "/dev/sdb", "/dev/sdc"])
|
|
|
assert ns.level.device[2].type.getValue() == "usbhdd"
|
|
|
assert [x.type.getValue() for x in ns.level.device] == ["hdd",
|
|
|
"flash",
|
|
|
"usbhdd"]
|
|
|
|
|
|
assert ns.level.device_child.getValue() == "hdd"
|
|
|
ns.level.devicelist.setValue(["/dev/sda", "/dev/sdb"])
|
|
|
ns.level.device[0].type.setValue("flash")
|
|
|
assert ns.level.device.getValue() == [{"dev": "/dev/sda",
|
|
|
"type": "flash",
|
|
|
"name": "Samsung SSD"},
|
|
|
{"dev": "/dev/sdb",
|
|
|
"type": "flash",
|
|
|
"name": "Transcend 64GB"}]
|
|
|
assert ns.level.device_child.getValue() == "flash"
|
|
|
|
|
|
# после установки хотя бы одного значения в table переменной
|
|
|
# обновление остальных прекращаются до инвалидации (так как
|
|
|
# значения рассматриваются комплексно)
|
|
|
ns.level.devicelist.setValue(["/dev/sda", "/dev/sdb", "/dev/sdc"])
|
|
|
assert [x.dev.getValue() for x in ns.level.device] == ["/dev/sda",
|
|
|
"/dev/sdb"]
|
|
|
ns.level.device.invalidate()
|
|
|
assert [x.dev.getValue() for x in ns.level.device] == ["/dev/sda",
|
|
|
"/dev/sdb",
|
|
|
"/dev/sdc"]
|
|
|
# проверить на повторное изменение, убедится, что _drop_child
|
|
|
# отрабатывает
|
|
|
ns.level.devicelist.setValue(["/dev/sda", "/dev/sdb",
|
|
|
"/dev/sdc", "/dev/sdd"])
|
|
|
ns.level.device.invalidate()
|
|
|
assert [x.dev.getValue() for x in ns.level.device] == ["/dev/sda",
|
|
|
"/dev/sdb",
|
|
|
"/dev/sdc",
|
|
|
"/dev/sdd"]
|
|
|
|
|
|
def test_wrong_table_variable(self):
|
|
|
class Testtable(TableVariable):
|
|
|
class Data(TableVariable.Data):
|
|
|
def get(self):
|
|
|
return [{'dev': '123', 'name': '098'}]
|
|
|
|
|
|
ns = Namespace()
|
|
|
ns.addNamespace(Namespace("test"))
|
|
|
ns.test.addNamespace(Namespace("test2"))
|
|
|
|
|
|
error_message = ("Missed 'hash_vars' attribute for table "
|
|
|
"variable test.test2.testtable")
|
|
|
with pytest.raises(VariableError) as e:
|
|
|
ns.test.test2.addNamespace(Testtable("testtable", ns.test.test2))
|
|
|
assert str(e.value) == error_message
|
|
|
|
|
|
def test_wrong_hash_variable(self):
|
|
|
class Testhash(HashVariable):
|
|
|
class Data(HashVariable.Data):
|
|
|
def get(self):
|
|
|
return {'dev': '123', 'name': '098'}
|
|
|
|
|
|
ns = Namespace()
|
|
|
ns.addNamespace(Namespace("test"))
|
|
|
ns.test.addNamespace(Namespace("test2"))
|
|
|
|
|
|
error_message = ("Missed 'hash_vars' attribute for hash "
|
|
|
"variable test.test2.testhash")
|
|
|
with pytest.raises(VariableError) as e:
|
|
|
ns.test.test2.addNamespace(Testhash("testhash", ns.test.test2))
|
|
|
assert str(e.value) == error_message
|
|
|
|
|
|
def test_namespace_iteration(self):
|
|
|
ns = Namespace()
|
|
|
ns0 = ns.addNamespace()
|
|
|
ns0.addStringVariable("test", "123")
|
|
|
ns1 = ns.addNamespace()
|
|
|
ns1.addStringVariable("test", "234")
|
|
|
ns2 = ns.addNamespace()
|
|
|
ns2.addStringVariable("test", "456")
|
|
|
|
|
|
assert [x.test.getValue() for x in ns] == ["123", "234", "456"]
|
|
|
|
|
|
def test_subnamespace(self):
|
|
|
ns = Namespace()
|
|
|
vl = VariableLoader()
|
|
|
vl.fill(ns, "tests/vars/variables", "testvars")
|
|
|
|
|
|
assert ns.level.level3.my_var1.getValue() == "testing"
|
|
|
assert ns.level.level3.myvar2.getValue() == "testing2"
|
|
|
|
|
|
def test_variable_not_found(self):
|
|
|
ns = Namespace()
|
|
|
vl = VariableLoader()
|
|
|
vl.fill(ns, "tests/vars/variables", "testvars")
|
|
|
|
|
|
error_message = "Variable or namespace level.level3.myvar3 not found"
|
|
|
with pytest.raises(VariableError) as e:
|
|
|
ns.level.level3.myvar3.getValue()
|
|
|
assert str(e.value) == error_message
|
|
|
|
|
|
# TODO: тест использует значения на конкретной машине
|
|
|
# def test_simple(self):
|
|
|
# ns = Namespace()
|
|
|
# vl = VariableLoader()
|
|
|
# vl.fill(ns, *VariableLoader.default())
|
|
|
# # нужно исправить тест, так
|
|
|
# # assert [x.name.getValue() for x in ns.os.gentoo.repositories] ==\
|
|
|
# ["gentoo","distros","calculate","custom"]
|
|
|
# assert ns.os.gentoo.make_profile.getValue() ==\
|
|
|
# "/etc/portage/make.profile"
|
|
|
# assert ns.os.gentoo.profile.path.getValue() ==\
|
|
|
# "/var/db/repos/distros/profiles/CLD/amd64/20"
|
|
|
# assert ns.os.gentoo.profile.name.getValue() == "distros:CLD/amd64/20"
|
|
|
|
|
|
def test_profile_filler(self):
|
|
|
ns = Namespace()
|
|
|
vl = VariableLoader()
|
|
|
vl.fill(ns, "tests/vars/variables", "testvars")
|
|
|
|
|
|
class ProfileFillerTest(ProfileFiller):
|
|
|
def getRepositoryMap(self, ns):
|
|
|
curdir = os.getcwd()
|
|
|
return {'distros':
|
|
|
os.path.join(curdir,
|
|
|
"tests/utils/gentoo/repos/distros"),
|
|
|
'calculate':
|
|
|
os.path.join(curdir,
|
|
|
"tests/utils/gentoo/repos/calculate"),
|
|
|
'gentoo':
|
|
|
os.path.join(curdir,
|
|
|
"tests/utils/gentoo/portage")}
|
|
|
|
|
|
assert ns.os.hashvar.value1.getValue() == "test1"
|
|
|
assert ns.os.hashvar.value2.getValue() == "test2"
|
|
|
|
|
|
assert ns.os.tablevar[0].dev.getValue() == "/dev/sdb1"
|
|
|
assert ns.os.tablevar[1].dev.getValue() == "/dev/sdb2"
|
|
|
|
|
|
pf = ProfileFillerTest()
|
|
|
pf.fill(ns, "tests/utils/gentoo/repos/distros/profiles/CLD/amd64")
|
|
|
|
|
|
assert ns.os.linux.test.getValue() == "test"
|
|
|
assert ns.os.linux.arch.getValue() == "amd64"
|
|
|
|
|
|
assert ns.os.linux.title.getValue() == "Calculate Linux Desktop KDE 20"
|
|
|
|
|
|
# Hash
|
|
|
assert ns.os.hashvar.value1.getValue() == "20"
|
|
|
assert ns.os.hashvar.value2.getValue() == "30"
|
|
|
|
|
|
ns.os.hashvar.value1.setValue("40")
|
|
|
assert ns.os.hashvar.value1.getValue() == "40"
|
|
|
ns.os.hashvar.value1.invalidate()
|
|
|
assert ns.os.hashvar.value1.getValue() == "20"
|
|
|
|
|
|
# Table
|
|
|
assert ns.os.tablevar[0].dev.getValue() == "/dev/sda1"
|
|
|
assert ns.os.tablevar[1].dev.getValue() == "/dev/sda2"
|
|
|
assert ns.os.tablevar[2].dev.getValue() == "/dev/sda5"
|
|
|
ns.os.tablevar[0].dev.invalidate()
|
|
|
assert ns.os.tablevar[0].dev.getValue() == "/dev/sda1"
|
|
|
assert ns.os.tablevar[1].dev.getValue() == "/dev/sda2"
|
|
|
assert ns.os.tablevar[2].dev.getValue() == "/dev/sda5"
|
|
|
|
|
|
def test_fill_namespace_by_module(self):
|
|
|
pass
|
|
|
# ns = Namespace()
|
|
|
# vl = VariableLoader()
|
|
|
# vl.fill(ns, *VariableLoader.default())
|
|
|
# assert "os" in ns
|
|
|
# assert "config" in ns.os.gentoo
|
|
|
# assert "main" in ns
|
|
|
# assert ns.os.gentoo.config.getValue() is not None
|
