From f879ea0ae276417bc569a4b9b3a2c98a7d39b225 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=D0=98=D0=B2=D0=B0=D0=BD=D0=BE=D0=B2=20=D0=94=D0=B5=D0=BD?= =?UTF-8?q?=D0=B8=D1=81?= Date: Mon, 13 Jul 2020 17:44:19 +0300 Subject: [PATCH] Some changes of the code design of the variables properies and some comments are added. --- calculate/utils/files.py | 13 +- calculate/vars/datavars.py | 177 ++++--- calculate/vars/vars_loader.py | 80 ++- tests/vars/test_namespace.py | 496 +++++++++--------- tests/vars/variables/level/__init__.py | 63 ++- tests/vars/variables/level/level2/__init__.py | 3 +- tests/vars/variables/main/__init__.py | 1 + tests/vars/variables/os/__init__.py | 14 +- 8 files changed, 439 insertions(+), 408 deletions(-) diff --git a/calculate/utils/files.py b/calculate/utils/files.py index a0af9d8..ff613f9 100644 --- a/calculate/utils/files.py +++ b/calculate/utils/files.py @@ -10,15 +10,6 @@ import sys import contextlib -def listDirectory(dn, fullpath=False): - if path.exists(dn): - if fullpath: - return [path.join(dn, x) for x in os.listdir(dn)] - else: - return os.listdir(dn) - return [] - - class FilesError(Exception): pass @@ -397,11 +388,11 @@ def quite_unlink(file_path): pass -def list_directory(directory_path, full_path=False, only_dir=False): +def list_directory(directory_path, fullpath=False, only_dir=False): if not path.exists(directory_path): return [] try: - if full_path: + if fullpath: if only_dir: return [node.path for node in os.scandir(directory_path) if os.path.isdir(node.path)] diff --git a/calculate/vars/datavars.py b/calculate/vars/datavars.py index ac1aa33..fedfd18 100644 --- a/calculate/vars/datavars.py +++ b/calculate/vars/datavars.py @@ -13,7 +13,7 @@ class BaseClass: BASE_CLASS = "BaseClass" @classmethod - def isImplementation(cls, check_class): + def is_implementation(cls, check_class): '''Метод для проверки того, что класс является производным базового класса, а не самим базовым. Используется в автозагрузке переменных из модулей.''' @@ -42,16 +42,20 @@ class CyclicVariableError(VariableError): class VariableProperty: + '''Базовый класс для объектов свойств.''' def __init__(self, parent): self.parent = parent class StringVariable(VariableProperty): + '''Класс свойства, соответствующий переменным просто хранящим строки как + значения.''' pass class ListVariable(VariableProperty): - def setValue(self, value, force=False): + '''Класс свойства, соответствующий переменным хранящим списки значений.''' + def set_value(self, value, force=False): if isinstance(value, (list, tuple)): return value elif isinstance(value, str): @@ -66,7 +70,7 @@ class ListVariable(VariableProperty): class ReadonlyVariable(VariableProperty): - def setValue(self, value, force=False): + def set_value(self, value, force=False): if not force: raise VariableError( _("Attempting to rewrite readonly variable {}").format( @@ -75,10 +79,10 @@ class ReadonlyVariable(VariableProperty): class IntegerVariable(VariableProperty): - reMatch = re.compile(r"^-?\d+$") + re_match = re.compile(r"^-?\d+$") def check(self, value): - if value and not self.reMatch.match(value): + if value and not self.re_match.match(value): raise VariableError( _("The value of variable '{varname}' must be integer").format( varname=self.parent.name)) @@ -103,12 +107,12 @@ class ChoiceVariable(VariableProperty): def choice(self): if self.parent.__class__.choice == Variable.choice and \ - self.parent.__class__.choiceComment == Variable.choiceComment: + self.parent.__class__.choice_comment == Variable.choice_comment: raise VariableError(_("Wrong choice variable {}").format( self.parent.name)) - return [x[0] for x in self.parent.choiceComment()] + return [x[0] for x in self.parent.choice_comment()] - def choiceComment(self): + def choice_comment(self): return [(x, x) for x in self.parent.choice()] @@ -117,7 +121,7 @@ class DefaultValue(VariableProperty): self.value = value self.parent = None - def getValue(self, invalidate_subs=None): + def get_value(self, invalidate_subs=None): if self.parent._value is None: self.parent._unsubscribe_depends() self.parent._value = self.value @@ -156,7 +160,8 @@ class Variable(BaseClass): @property def fullname(self): - return "{}.{}".format(self.vars.getFullname(), self.name) + '''Метод для получения полного имени переменной.''' + return "{}.{}".format(self.vars.get_fullname(), self.name) def addProperty(self, prop): prop.parent = self @@ -196,7 +201,7 @@ class Variable(BaseClass): self.invalidate_subs = set() self._emit_invalidate(slots) - def setParent(self, namespace): + def set_parent(self, namespace): self.vars = namespace @contextmanager @@ -207,8 +212,8 @@ class Variable(BaseClass): finally: self.calculating = False - def getValue(self, invalidate_sub=None): - for f in self.callProperties("getValue"): + def get_value(self, invalidate_sub=None): + for f in self.call_properties("get_value"): f(invalidate_sub) if self.calculating: raise CyclicVariableError(self.name) @@ -227,21 +232,25 @@ class Variable(BaseClass): return self.post_get(self._value) def post_get(self, value): - for f in self.callProperties("post_get"): + for f in self.call_properties("post_get"): ret = f(value) if ret is not None: return ret return value - def callProperties(self, fname, *args): - for prop in self._properties: - f = getattr(prop, fname, None) - if f: - yield f - - def setValue(self, value, force=False): - for f in self.callProperties("setValue"): - value = f(value, force) + def call_properties(self, method_name, *args): + '''Метод для вызова указанного метода у всех объектов, которыми владеет + переменная.''' + for _property in self._properties: + method = getattr(_property, method_name, None) + if method: + yield method + + def set_value(self, value, force=False): + '''Метод для установки некоторого заданного значения всем объектам, + принадлежащим переменной.''' + for setter in self.call_properties("set_value"): + value = setter(value, force) value = self.set(value) self.check(value) self.invalidate() @@ -249,26 +258,28 @@ class Variable(BaseClass): self._unsubscribe_depends() def check(self, value): - '''Метод для проверки значения устанавливаемого значения.''' - for f in self.callProperties("check"): - f(value) + '''Метод для проверки корректности устанавливаемого значения путем + вызова проверочных методов всех объектов, которыми владеет переменная. + ''' + for checker in self.call_properties("check"): + checker(value) def get(self): '''Метод для заполнения переменной.''' return self.value - def getCommentValue(self, invalidate_sub=None): + def get_comment_value(self, invalidate_sub=None): '''Этот метод вызывается внутри методов get.''' - val = self.getComment() + val = self.get_comment() if invalidate_sub is not None: self.update_subscribe(invalidate_sub) return val - def getComment(self): - '''Комментарий к значению.''' - for f in self.callProperties("getComment"): + def get_comment(self): + '''Метод для установки .''' + for f in self.call_properties("get_comment"): return f() - return self.getValue() + return self.get_value() def set(self, value): '''Метод для модификации переменной.''' @@ -276,12 +287,12 @@ class Variable(BaseClass): def choice(self): '''Метод возвращет список доступных значений для переменной.''' - for f in self.callProperties("choice"): + for f in self.call_properties("choice"): return f() return [] - def choiceComment(self): - for f in self.callProperties("choiceComment"): + def choice_comment(self): + for f in self.call_properties("choice_comment"): return f() return [] @@ -291,6 +302,7 @@ class NamespaceError(Exception): class Namespace(BaseClass): + '''Класс пространства имен.''' BASE_CLASS = "Namespace" def __init__(self, name="", parent=None): @@ -299,11 +311,13 @@ class Namespace(BaseClass): self.childs = {} self.parent = parent or self self.root = self - self._nextns = 0 + self._next_namespace = 0 - def getFullname(self): + def get_fullname(self): + '''Метод для получения полного имени пространства имен, включающего в + себя имена всех родительских пространств имен.''' if self.parent is not self and self.parent.parent is not self.parent: - return "{}.{}".format(self.parent.getFullname(), self._name) + return "{}.{}".format(self.parent.get_fullname(), self._name) else: return self._name @@ -315,22 +329,24 @@ class Namespace(BaseClass): else: raise VariableNotFoundError( _("Variable or namespace {varname} not found").format( - varname="{}.{}".format(self.getFullname(), - name))) + varname="{}.{}".format(self.get_fullname(), + name))) - def clearChilds(self): + def clear_childs(self): + '''Метод для глубокой очистки пространства имен от всех дочерних + пространств имен.''' for child in self.childs.values(): - child.clearChilds() + child.clear_childs() self.childs = {} def __getitem__(self, name): return getattr(self, str(name)) def __setitem__(self, name, value): - return getattr(self, str(name)).setValue(value) + return getattr(self, str(name)).set_value(value) def __iter__(self): - '''Сортировка: вначале числовые ключи потом прочие.''' + # Сортировка: вначале числовые ключи потом прочие. def sortkey(x): k, v = x if k.isdigit(): @@ -343,39 +359,46 @@ class Namespace(BaseClass): def __contains__(self, name): return name in self.childs or name in self.variables - def addStringVariable(self, varname, value): + def add_string_variable(self, varname: str, value: str): + '''Метод для добавления переменной с помощью строк.''' var = Variable(varname) var.value = value - var.setParent(self) + var.set_parent(self) self.variables[varname] = var - def addVariable(self, variable): + def add_variable(self, variable: Variable): + '''Метод для добавления переменной.''' self.variables[variable.name] = variable - variable.setParent(self) + variable.set_parent(self) - def _getNextNamespaceName(self): - name = str(self._nextns) + def _get_next_namespace_name(self): + '''Метод для получения имени следующего по счету пространства имен.''' + name = str(self._next_namespace) while name in self.childs: - self._nextns += 1 - name = str(self._nextns) + self._next_namespace += 1 + name = str(self._next_namespace) return name - def addNamespace(self, namespace=None, name=None): + def add_namespace(self, namespace=None, name=None): + '''Метод для добавления пространств имен.''' if name is None: if namespace is None: - name = self._getNextNamespaceName() + name = self._get_next_namespace_name() else: name = namespace._name + if namespace is None: namespace = Namespace(name) + self.childs[name] = namespace namespace.parent = self namespace.root = self.root + return namespace class HashVariable(Namespace): - """Классс переменных представляющих собой словарь.""" + '''Класс переменных, представляющих собой словарь.''' BASE_CLASS = "HashVariable" class HashValue(Variable): @@ -386,10 +409,10 @@ class HashVariable(Namespace): self.parent = None self.master_variable = master_variable - def getValue(self, invalidate_sub=None): + def get_value(self, invalidate_sub=None): return self.master_variable.getHashValue(self.name, invalidate_sub) - def setValue(self, value, force=False): + def set_value(self, value, force=False): return self.master_variable.setHashValue(self.name, value, force) def invalidate(self): @@ -399,19 +422,19 @@ class HashVariable(Namespace): BASE_CLASS = "Data" def getHashValue(self, name, invalidate_sub=None): - return self.getValue(invalidate_sub)[name] + return self.get_value(invalidate_sub)[name] def setHashValue(self, name, value, force): if name in self.readonly_vars and not force: raise VariableError( _("Attempting to rewrite readonly variable {}"). format(name)) - data = self.getValue().copy() + data = self.get_value().copy() data[name] = value - self.setValue(data, force) + self.set_value(data, force) - def getValue(self, invalidate_sub=None): - return self.master_variable.getValue(invalidate_sub) + def get_value(self, invalidate_sub=None): + return self.master_variable.get_value(invalidate_sub) hash_vars = [] readonly_vars = [] @@ -425,13 +448,13 @@ class HashVariable(Namespace): if not self.hash_vars: raise VariableError( _("Missed '{attrname}' attribute for hash variable {varname}"). - format(attrname="hash_vars", varname=self.getFullname())) + format(attrname="hash_vars", varname=self.get_fullname())) self.master_variable = self.Data(name) - self.master_variable.setParent(parent) + self.master_variable.set_parent(parent) self.master_variable.readonly_vars = self.readonly_vars for varname in self.hash_vars: var = self.HashValue(varname, self.master_variable) - self.addVariable(var) + self.add_variable(var) def invalidate(self): self.master_variable.invalidate() @@ -465,7 +488,7 @@ class TableVariable(Namespace): BASE_CLASS = "Data" def getTableValue(self, name, index, invalidate_sub=None): - data = self.getValue(invalidate_sub) + data = self.get_value(invalidate_sub) return data[index][name] def setTableValue(self, name, index, value, force): @@ -473,15 +496,15 @@ class TableVariable(Namespace): raise VariableError( _("Attempting to rewrite readonly variable {}").format( name)) - data = [x.copy() for x in self.getValue()] + data = [x.copy() for x in self.get_value()] rowdata = data[index] rowdata[name] = value - self.setValue(data, force) + self.set_value(data, force) @property def childs(self): if self._childs is None: - value = self.master_variable.getValue() + value = self.master_variable.get_value() self._childs = {} for i, row in enumerate(value): hashvar = self.TableHashVariable(self.master_variable.name, @@ -494,11 +517,11 @@ class TableVariable(Namespace): def childs(self, value): self._childs = value - def getValue(self, invalidate_sub=None): - return self.master_variable.getValue(invalidate_sub) + def get_value(self, invalidate_sub=None): + return self.master_variable.get_value(invalidate_sub) - def setValue(self, value, force=False): - self.master_variable.setValue(value, force) + def set_value(self, value, force=False): + self.master_variable.set_value(value, force) def invalidate(self): self.master_variable.invalidate() @@ -510,8 +533,8 @@ class TableVariable(Namespace): self._childs = None self.master_variable.update_subscribe(self._drop_childs) - def clearChilds(self): - super().clearChilds() + def clear_childs(self): + super().clear_childs() self._drop_childs() def __init__(self, name, parent=None): @@ -522,8 +545,8 @@ class TableVariable(Namespace): raise VariableError( _("Missed '{attrname}' attribute for table variable {varname}"). format(attrname="hash_vars", - varname=self.getFullname())) + varname=self.get_fullname())) self.master_variable = self.Data(name) - self.master_variable.setParent(parent) + self.master_variable.set_parent(parent) self.master_variable.readonly_vars = self.readonly_vars self.master_variable.update_subscribe(self._drop_childs) diff --git a/calculate/vars/vars_loader.py b/calculate/vars/vars_loader.py index ec28733..3e6286f 100644 --- a/calculate/vars/vars_loader.py +++ b/calculate/vars/vars_loader.py @@ -9,7 +9,7 @@ from calculate.vars.datavars import Variable, Namespace, HashVariable,\ TableVariable, IniCreated, DefaultValue from calculate.utils.gentoo import ProfileWalker from calculate.utils.fs import readFile -from calculate.utils.files import listDirectory +from calculate.utils.files import list_directory class NamespaceIniFiller(CalculateIniParser): @@ -28,7 +28,7 @@ class NamespaceIniFiller(CalculateIniParser): self.curns = self.ns for section in sections: if section not in self.curns.childs: - self.curns.addNamespace(Namespace(section)) + self.curns.add_namespace(Namespace(section)) self.curns = self.curns[section] def clear_section(self, sections): @@ -37,16 +37,16 @@ class NamespaceIniFiller(CalculateIniParser): if section not in curns.childs: return curns = curns[section] - curns.clearChilds() + curns.clear_childs() def change_value(self, key, value): - self.curns[key].setValue(value) + self.curns[key].set_value(value) def define_variable(self, key, value): - self.curns.addStringVariable(key, value) + self.curns.add_string_variable(key, value) def append_value(self, key, value): - l = self.curns[key].getValue().split(",") + l = self.curns[key].get_value().split(",") vlist = value.split(",") for v in vlist: if v not in l: @@ -54,7 +54,7 @@ class NamespaceIniFiller(CalculateIniParser): self.change_value(key, ",".join(l)) def remove_value(self, key, value): - l = self.curns[key].getValue().split(",") + l = self.curns[key].get_value().split(",") vlist = value.split(",") for v in vlist: if v in l: @@ -94,7 +94,7 @@ class NamespaceIniFillerStrict(NamespaceIniFiller): self.canCreate = False for newns in self.availableSection: if newns not in ns: - ns.addNamespace(Namespace(newns)) + ns.add_namespace(Namespace(newns)) super().fill(ns, data) def start_section(self, sections): @@ -103,34 +103,34 @@ class NamespaceIniFillerStrict(NamespaceIniFiller): for section in sections: if section not in self.curns.childs: if isinstance(self.curns, TableVariable) or self.canCreate: - self.curns.addNamespace(Namespace(section)) + self.curns.add_namespace(Namespace(section)) else: self.curns = None self.curns = self.curns[section] - #def clear_section(self, sections): - # curns = self.ns - # self.canCreate = sections[0] in self.availableSection - # for section in sections: - # if section not in curns.childs: - # return - # curns = curns[section] - # curns.clearChilds() + # def clear_section(self, sections): + # curns = self.ns + # self.canCreate = sections[0] in self.availableSection + # for section in sections: + # if section not in curns.childs: + # return + # curns = curns[section] + # curns.clear_childs() def define_variable(self, key, value): if not self.canCreate: pass var = Variable(key) var.addProperty(IniCreated(value)) - self.curns.addVariable(var) + self.curns.add_variable(var) def change_value(self, key, value): var = self.curns[key] - var.setValue(value) + var.set_value(value) if isinstance(var, HashVariable.HashValue): var = var.master_variable - value = var.getValue() + value = var.get_value() prop = var.findProperty(DefaultValue) if prop: @@ -141,40 +141,34 @@ class NamespaceIniFillerStrict(NamespaceIniFiller): class VariableLoader: - """ - Объект используемый для загрузки переменных из python модуля - """ - reUpper = re.compile("(.)([A-Z])") + '''Класс, используемый для загрузки переменных из python модуля.''' + re_upper = re.compile("(.)([A-Z])") def _get_varlike_attrs(self, obj): - """ - Получить список аттрибутов похожих на переменные - """ + '''Метод для получения списка аттрибутов похожих на переменные.''' for attrname in (x for x in dir(obj) if x[:1].isupper()): - yield self.reUpper.sub(r"\1_\2", attrname).lower(), \ + yield self.re_upper.sub(r"\1_\2", attrname).lower(), \ getattr(obj, attrname) def fill(self, ns, dirpath, package): - """ - Загрузить в namespace переменные из указанных модулей - """ - for fullfn in listDirectory(dirpath, fullpath=True): + '''Загрузить в namespace переменные из указанных модулей.''' + for fullfn in list_directory(dirpath, fullpath=True): dn, fn = os.path.split(fullfn) if os.path.isdir(fullfn): - newns = ns.addNamespace(Namespace(fn)) - self.fill(newns, fullfn, "%s.%s"%(package,fn)) + newns = ns.add_namespace(Namespace(fn)) + self.fill(newns, fullfn, "{}.{}".format(package, fn)) elif fn.endswith(".py"): module = self._load_module_source(package, fn, fullfn) for varname, cls in self._get_varlike_attrs(module): - if Variable.isImplementation(cls): - ns.addVariable(cls(varname)) - elif HashVariable.isImplementation(cls) or \ - TableVariable.isImplementation(cls) or \ - Namespace.isImplementation(cls): - _newns = ns.addNamespace(cls(varname,ns)) + if Variable.is_implementation(cls): + ns.add_variable(cls(varname)) + elif HashVariable.is_implementation(cls) or \ + TableVariable.is_implementation(cls) or \ + Namespace.is_implementation(cls): + _newns = ns.add_namespace(cls(varname, ns)) for _varname, _cls in self._get_varlike_attrs(cls): - if Variable.isImplementation(_cls): - _newns.addVariable(_cls(_varname)) + if Variable.is_implementation(_cls): + _newns.add_variable(_cls(_varname)) @classmethod def default(cls): @@ -207,7 +201,7 @@ class ProfileFiller: basename = "calculate.ini" def get_repository_map(self, ns): return { - x.name.getValue(): x.path.getValue() + x.name.get_value(): x.path.get_value() for x in ns.os.gentoo.repositories } diff --git a/tests/vars/test_namespace.py b/tests/vars/test_namespace.py index 0680879..3bf2e9f 100644 --- a/tests/vars/test_namespace.py +++ b/tests/vars/test_namespace.py @@ -19,20 +19,20 @@ class TestNamespace: 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" + ns.add_string_variable("test", "12345") + assert ns.test.get_value() == "12345" + ns.add_string_variable("zxcv", "23456") + assert ns.zxcv.get_value() == "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" + ns.add_namespace(Namespace("os")) + ns.os.add_string_variable("test", "123") + ns.os.add_namespace(Namespace("linux")) + ns.os.linux.add_string_variable("shortname", "CLD") + assert ns.os.test.get_value() == "123" + assert ns.os["test"].get_value() == "123" + assert ns.os.linux.shortname.get_value() == "CLD" assert ns.os.root == ns def test_fill_namespace_simple(self): @@ -47,9 +47,9 @@ class TestNamespace: 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.test.get_value() == "123" + assert ns.os.linux.shortname.get_value() == "CLD" + assert ns.os.linux.fullname.get_value() == "Calculate Linux Desktop" assert ns.os.linux.root == ns nsif.fill(ns, """ @@ -57,8 +57,8 @@ class TestNamespace: shortname = CLDX """) - assert ns.os.linux.shortname.getValue() == "CLDX" - assert ns.os.linux.fullname.getValue() == "Calculate Linux Desktop" + assert ns.os.linux.shortname.get_value() == "CLDX" + assert ns.os.linux.fullname.get_value() == "Calculate Linux Desktop" def test_fill_namespace_append_and_remove(self): ns = Namespace() @@ -71,28 +71,28 @@ class TestNamespace: test += 345 """) - assert ns.os.test.getValue() == "123,345" + assert ns.os.test.get_value() == "123,345" nsif.fill(ns, """ [os] test -= 123 """) - assert ns.os.test.getValue() == "345" + assert ns.os.test.get_value() == "345" nsif.fill(ns, """ [os] test += asdf,qwer,zxcv """) - assert ns.os.test.getValue() == "345,asdf,qwer,zxcv" + assert ns.os.test.get_value() == "345,asdf,qwer,zxcv" nsif.fill(ns, """ [os] test -= asdf,zxcv """) - assert ns.os.test.getValue() == "345,qwer" + assert ns.os.test.get_value() == "345,qwer" def test_fill_namespace_clear_namespaces(self): ns = Namespace() @@ -111,9 +111,9 @@ class TestNamespace: mount = /var/calculate """) - assert [x.dev.getValue() for x in ns.test] == ['/dev/sda1', - '/dev/sda2', - '/dev/sda5'] + assert [x.dev.get_value() for x in ns.test] == ['/dev/sda1', + '/dev/sda2', + '/dev/sda5'] nsif.fill(ns, """ [test][0] @@ -125,9 +125,9 @@ class TestNamespace: mount = / """) - assert [x.dev.getValue() for x in ns.test] == ['/dev/sdb1', - '/dev/sdb2', - '/dev/sda5'] + assert [x.dev.get_value() for x in ns.test] == ['/dev/sdb1', + '/dev/sdb2', + '/dev/sda5'] nsif.fill(ns, """ [test][] @@ -141,8 +141,8 @@ class TestNamespace: mount = / """) - assert [x.dev.getValue() for x in ns.test] == ['/dev/sdb1', - '/dev/sdb2'] + assert [x.dev.get_value() for x in ns.test] == ['/dev/sdb1', + '/dev/sdb2'] def test_fill_namespace_strict_clear(self): ns = Namespace() @@ -167,8 +167,8 @@ class TestNamespace: zxcv = 2 """) - assert ns.custom.test.zxcv.getValue() == "1" - assert ns.custom.test2.zxcv.getValue() == "2" + assert ns.custom.test.zxcv.get_value() == "1" + assert ns.custom.test2.zxcv.get_value() == "2" nsifs = NamespaceIniFillerStrict() nsifs.fill(ns, """ @@ -182,16 +182,16 @@ class TestNamespace: def test_get_namespace_attrs(self): ns = Namespace() os = Namespace("os") - os.addStringVariable("test", "zxcv") - ns.addNamespace(os) + os.add_string_variable("test", "zxcv") + ns.add_namespace(os) - assert ns.os.test.getValue() == "zxcv" - assert ns.os["test"].getValue() == "zxcv" + assert ns.os.test.get_value() == "zxcv" + assert ns.os["test"].get_value() == "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" + ns.os.test.set_value("123") + assert ns.os.test.get_value() == "123" + ns.os["test"].set_value("234") + assert ns.os.test.get_value() == "234" def test_variable_get_value(self): class TestVar(Variable): @@ -200,62 +200,62 @@ class TestNamespace: var = TestVar("test") - assert var.getValue() == "A" + assert var.get_value() == "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" + ns.add_namespace(os) + os.add_namespace(linux) + os.add_namespace(device) + device1 = device.add_namespace() + device1.add_string_variable("dev", "/dev/sda") + device2 = device.add_namespace() + device2.add_string_variable("dev", "/dev/sdb") + device3 = device.add_namespace() + device3.add_string_variable("dev", "/dev/sdc") + + ns.add_string_variable("first", "first") + os.add_string_variable("second", "second") + linux.add_string_variable("third", "third") + + assert ns.first.get_value() == "first" + assert ns.root.os.second.get_value() == "second" + assert ns.os.second.get_value() == "second" + assert os.root.os.second.get_value() == "second" + assert os.second.get_value() == "second" + assert linux.third.get_value() == "third" + assert linux.root.os.second.get_value() == "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[0].dev.get_value() == "/dev/sda" + assert ns.os.device["0"].dev.get_value() == "/dev/sda" + assert ns.os.device[1].dev.get_value() == "/dev/sdb" + assert ns.os.device[2].dev.get_value() == "/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.second.get_value() == "second" + assert ns.os.device.parent.parent.os.second.get_value() == "second" assert ns.os.device.parent.parent.parent.os.second.\ - getValue() == "second" + get_value() == "second" def test_variable_get_value_by_variable(self): class TestVar1(Variable): def get(self): - return "%s,B" % self.vars.test2.getValue(self) + return "%s,B" % self.vars.test2.get_value(self) class TestVar2(Variable): def get(self): return "A" ns = Namespace() - ns.addVariable(TestVar1("test1")) - ns.addVariable(TestVar2("test2")) + ns.add_variable(TestVar1("test1")) + ns.add_variable(TestVar2("test2")) - assert ns.test1.getValue() == "A,B" + assert ns.test1.get_value() == "A,B" def test_variable_get_value_by_changed_variable(self): class TestVar1(Variable): @@ -263,59 +263,59 @@ class TestNamespace: def get(self): self.counter += 1 - return "%s,B" % self.vars.test2.getValue(self) + return "%s,B" % self.vars.test2.get_value(self) ns = Namespace() test1 = TestVar1("test1") - ns.addVariable(test1) - ns.addStringVariable("test2", "A") + ns.add_variable(test1) + ns.add_string_variable("test2", "A") - assert ns.test1.getValue() == "A,B" + assert ns.test1.get_value() == "A,B" assert test1.counter == 1 # test for get cached variable value - assert ns.test1.getValue() == "A,B" + assert ns.test1.get_value() == "A,B" assert test1.counter == 1 # change value of test2 for recalculate test1 - ns.test2.setValue("C") - assert ns.test1.getValue() == "C,B" + ns.test2.set_value("C") + assert ns.test1.get_value() == "C,B" assert test1.counter == 2 # change value of test2 for recalculate test1 - ns.test2.setValue("D") - assert ns.test1.getValue() == "D,B" + ns.test2.set_value("D") + assert ns.test1.get_value() == "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) + return "%s,test1" % self.vars.test2.get_value(self) class TestVar2(Variable): def get(self): - return "%s,test2" % self.vars.test3.getValue(self) + return "%s,test2" % self.vars.test3.get_value(self) class TestVar3(Variable): def get(self): - return "%s,test3" % self.vars.test1.getValue(self) + return "%s,test3" % self.vars.test1.get_value(self) test1 = TestVar1("test1") test2 = TestVar2("test2") test3 = TestVar3("test3") ns = Namespace() - ns.addVariable(test1) - ns.addVariable(test2) - ns.addVariable(test3) + ns.add_variable(test1) + ns.add_variable(test2) + ns.add_variable(test3) with pytest.raises(CyclicVariableError) as e: - ns.test1.getValue() + ns.test1.get_value() assert e.value.queue[:-1] == ("test1", "test2", "test3") with pytest.raises(VariableError) as e: - ns.test1.getValue() + ns.test1.get_value() def test_drop_invalidate_after_set_value(self): class TestVar1(Variable): @@ -323,7 +323,7 @@ class TestNamespace: def get(self): self.counter += 1 - return "%s,test1" % self.vars.test2.getValue(self) + return "%s,test1" % self.vars.test2.get_value(self) class TestVar2(Variable): def get(self): @@ -332,24 +332,24 @@ class TestNamespace: test1 = TestVar1("test1") test2 = TestVar2("test2") ns = Namespace() - ns.addVariable(test1) - ns.addVariable(test2) + ns.add_variable(test1) + ns.add_variable(test2) - assert test1.getValue() == "ZZZZ,test1" + assert test1.get_value() == "ZZZZ,test1" - test1.setValue("VVVV") + test1.set_value("VVVV") - assert test1.getValue() == "VVVV" + assert test1.get_value() == "VVVV" assert test1.counter == 1 - test2.setValue("XXXX") + test2.set_value("XXXX") - assert test1.getValue() == "VVVV" + assert test1.get_value() == "VVVV" assert test1.counter == 1 test1.invalidate() - assert test1.getValue() == "XXXX,test1" + assert test1.get_value() == "XXXX,test1" assert test1.counter == 2 def test_change_invalidator_variable(self): @@ -359,31 +359,31 @@ class TestNamespace: def get(self): self.counter += 1 - if self.vars.ifvar.getValue(self): - return "%s,test1" % self.vars.vara.getValue(self) + if self.vars.ifvar.get_value(self): + return "%s,test1" % self.vars.vara.get_value(self) else: - return "%s,test1" % self.vars.varb.getValue(self) + return "%s,test1" % self.vars.varb.get_value(self) vartest = VarTest("vartest") ns = Namespace() - ns.addVariable(vartest) - ns.addStringVariable("vara", "vara") - ns.addStringVariable("varb", "varb") - ns.addStringVariable("ifvar", "true") + ns.add_variable(vartest) + ns.add_string_variable("vara", "vara") + ns.add_string_variable("varb", "varb") + ns.add_string_variable("ifvar", "true") - assert vartest.getValue() == "vara,test1" + assert vartest.get_value() == "vara,test1" assert vartest.counter == 1 - ns.vara.setValue("varc") - assert vartest.getValue() == "varc,test1" + ns.vara.set_value("varc") + assert vartest.get_value() == "varc,test1" assert vartest.counter == 2 - ns.ifvar.setValue("") - assert vartest.getValue() == "varb,test1" + ns.ifvar.set_value("") + assert vartest.get_value() == "varb,test1" assert vartest.counter == 3 - ns.vara.setValue("vard") - assert vartest.getValue() == "varb,test1" + ns.vara.set_value("vard") + assert vartest.get_value() == "varb,test1" assert vartest.counter == 3 def test_readonly_varaible(self): @@ -394,14 +394,14 @@ class TestNamespace: return "test1" test1 = TestVar1("test1") - assert test1.getValue() == "test1" + assert test1.get_value() == "test1" with pytest.raises(VariableError): - test1.setValue("test2") + test1.set_value("test2") - assert test1.getValue() == "test1" - test1.setValue("test2", force=True) - assert test1.getValue() == "test2" + assert test1.get_value() == "test1" + test1.set_value("test2", force=True) + assert test1.get_value() == "test2" def test_choice_variable(self): class TestVar1(Variable): @@ -412,9 +412,9 @@ class TestNamespace: test1 = TestVar1("test1") with pytest.raises(VariableError): - test1.setValue("test3") - test1.setValue("test2") - assert test1.getValue() == "test2" + test1.set_value("test3") + test1.set_value("test2") + assert test1.get_value() == "test2" def test_integer_variable(self): class TestVar1(Variable): @@ -422,11 +422,11 @@ class TestNamespace: test1 = TestVar1("test1") with pytest.raises(VariableError): - test1.setValue("test3") - test1.setValue("33") - assert test1.getValue() == 33 - test1.setValue("-33") - assert test1.getValue() == -33 + test1.set_value("test3") + test1.set_value("33") + assert test1.get_value() == 33 + test1.set_value("-33") + assert test1.get_value() == -33 def test_default_value_property(self): class TestVar1(Variable): @@ -434,14 +434,14 @@ class TestNamespace: return "123" test1 = TestVar1("test1") - assert test1.getValue() == "123" + assert test1.get_value() == "123" - test1.setValue("987") + test1.set_value("987") test1.addProperty(DefaultValue("567")) - assert test1.getValue() == "987" + assert test1.get_value() == "987" test1.invalidate() - assert test1.getValue() == "567" + assert test1.get_value() == "567" def test_get_comment(self): class TestVar1(Variable): @@ -452,30 +452,30 @@ class TestNamespace: def get(self): return "234" - def getComment(self): - return "[%s]" % self.getValue() + def get_comment(self): + return "[%s]" % self.get_value() class TestVar3(Variable): def get(self): - return "ZXC %s" % self.vars.test2.getCommentValue(self) + return "ZXC %s" % self.vars.test2.get_comment_value(self) ns = Namespace() test1 = TestVar1("test1") - assert test1.getValue() == "123" - assert test1.getComment() == "123" + assert test1.get_value() == "123" + assert test1.get_comment() == "123" test2 = TestVar2("test2") - assert test2.getValue() == "234" - assert test2.getComment() == "[234]" + assert test2.get_value() == "234" + assert test2.get_comment() == "[234]" test3 = TestVar3("test3") - ns.addVariable(test1) - ns.addVariable(test2) - ns.addVariable(test3) + ns.add_variable(test1) + ns.add_variable(test2) + ns.add_variable(test3) - assert test3.getValue() == "ZXC [234]" - test2.setValue("567") - assert test3.getValue() == "ZXC [567]" + assert test3.get_value() == "ZXC [234]" + test2.set_value("567") + assert test3.get_value() == "ZXC [567]" def test_wrong_choice_varaible(self): class TestVar1(Variable): @@ -490,7 +490,7 @@ class TestNamespace: class TestVar3(Variable): properties = [ChoiceVariable] - def choiceComment(self): + def choice_comment(self): return [("test1", "Test1"), ("test2", "Test2")] @@ -502,30 +502,30 @@ class TestNamespace: test1.choice() with pytest.raises(VariableError): - test1.choiceComment() + test1.choice_comment() assert test2.choice() == ["test1", "test2"] - assert test2.choiceComment() == [("test1", "test1"), - ("test2", "test2")] + assert test2.choice_comment() == [("test1", "test1"), + ("test2", "test2")] assert test3.choice() == ["test1", "test2"] - assert test3.choiceComment() == [("test1", "Test1"), - ("test2", "Test2")] + assert test3.choice_comment() == [("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" + assert ns.level.simple.get_value() == "simple value" + assert ns.level.uselocalsimple.get_value() == "Using simple value" + assert ns.level.usefullsimple.get_value() == "Using simple value" with pytest.raises(VariableError): ns.level.badchoice.choice() with pytest.raises(VariableError): - ns.level.badchoice.choiceComment() + ns.level.badchoice.choice_comment() assert ns.level.simple_choice.choice() == ["/dev/sda1", "/dev/sda2", @@ -533,23 +533,23 @@ class TestNamespace: assert ns.level.comment_choice.choice() == ["/dev/sda1", "/dev/sda2", "/dev/sda3"] - assert ns.level.comment_choice.choiceComment() == [ + assert ns.level.comment_choice.choice_comment() == [ ("/dev/sda1", "SWAP"), ("/dev/sda2", "ROOT"), ("/dev/sda3", "DATA")] - ns.level.disks.setValue(["/dev/sda2", "/dev/sda1"]) + ns.level.disks.set_value(["/dev/sda2", "/dev/sda1"]) - assert ns.level.disks.getValue() == ["/dev/sda2", "/dev/sda1"] + assert ns.level.disks.get_value() == ["/dev/sda2", "/dev/sda1"] assert ns.level.comment_choice.choice() == ["/dev/sda2", "/dev/sda1"] - assert ns.level.comment_choice.choiceComment() == [ + assert ns.level.comment_choice.choice_comment() == [ ("/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" + assert ns.level.level2.vargetter.get_value() == "/ test" def test_hash_variable(self): # hash variable @@ -557,43 +557,43 @@ class TestNamespace: vl = VariableLoader() vl.fill(ns, "tests/vars/variables", "testvars") - assert ns.level.linux.getFullname() == "level.linux" + assert ns.level.linux.get_fullname() == "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" + assert ns.level.linux.ver.get_value() == "1.0" + assert ns.level.linux.shortname.get_value() == "CLD" # проверка обновления значения hash переменной при обновлении # значения у зависимой перемнной - ns.level.version.setValue("2.0") - assert ns.level.linux.ver.getValue() == "2.0" + ns.level.version.set_value("2.0") + assert ns.level.linux.ver.get_value() == "2.0" # проверка установки значения hash переменной - ns.level.linux.ver.setValue("3.0") - assert ns.level.linux.ver.getValue() == "3.0" + ns.level.linux.ver.set_value("3.0") + assert ns.level.linux.ver.get_value() == "3.0" # после установки хотя бы одного значения в hash переменной # обновление остальных прекращаются до инвалидации (так как # значения рассматриваются комплексно) - ns.level.myshortname.setValue("CLDG") - assert ns.level.linux.shortname.getValue() == "CLD" + ns.level.myshortname.set_value("CLDG") + assert ns.level.linux.shortname.get_value() == "CLD" # проверка попытки изменить readonly переменную with pytest.raises(VariableError): - ns.level.linux.shortname.setValue("CLDX") + ns.level.linux.shortname.set_value("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.ver.get_value() == "2.0" + assert ns.level.linux.shortname.get_value() == "CLDG" - assert ns.level.linux.test.getValue() == "my test - 2.0" + assert ns.level.linux.test.get_value() == "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" + assert ns.level.shortname_test.get_value() == "CLDG test" + ns.level.linux.shortname.set_value("CLDX", force=True) + assert ns.level.shortname_test.get_value() == "CLDX test" def test_table_variable(self): # table variable @@ -601,53 +601,53 @@ class TestNamespace: 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" + assert ns.level.device[0].dev.get_value() == "/dev/sda" + assert ns.level.device[1].dev.get_value() == "/dev/sdb" + assert ns.level.device.get_value() == [{"dev": "/dev/sda", + "type": "hdd", + "name": "Samsung SSD"}, + {"dev": "/dev/sdb", + "type": "flash", + "name": "Transcend 64GB"}] + assert ns.level.device[1].type.get_value() == "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" + ns.level.devicelist.set_value(["/dev/sda", "/dev/sdb", "/dev/sdc"]) + assert ns.level.device[2].type.get_value() == "usbhdd" + assert [x.type.get_value() for x in ns.level.device] == ["hdd", + "flash", + "usbhdd"] + + assert ns.level.device_child.get_value() == "hdd" + ns.level.devicelist.set_value(["/dev/sda", "/dev/sdb"]) + ns.level.device[0].type.set_value("flash") + assert ns.level.device.get_value() == [{"dev": "/dev/sda", + "type": "flash", + "name": "Samsung SSD"}, + {"dev": "/dev/sdb", + "type": "flash", + "name": "Transcend 64GB"}] + assert ns.level.device_child.get_value() == "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.devicelist.set_value(["/dev/sda", "/dev/sdb", "/dev/sdc"]) + assert [x.dev.get_value() 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"] + assert [x.dev.get_value() for x in ns.level.device] == ["/dev/sda", + "/dev/sdb", + "/dev/sdc"] # проверить на повторное изменение, убедится, что _drop_child # отрабатывает - ns.level.devicelist.setValue(["/dev/sda", "/dev/sdb", + ns.level.devicelist.set_value(["/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"] + assert [x.dev.get_value() for x in ns.level.device] == ["/dev/sda", + "/dev/sdb", + "/dev/sdc", + "/dev/sdd"] def test_wrong_table_variable(self): class Testtable(TableVariable): @@ -656,13 +656,13 @@ class TestNamespace: return [{'dev': '123', 'name': '098'}] ns = Namespace() - ns.addNamespace(Namespace("test")) - ns.test.addNamespace(Namespace("test2")) + ns.add_namespace(Namespace("test")) + ns.test.add_namespace(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)) + ns.test.test2.add_namespace(Testtable("testtable", ns.test.test2)) assert str(e.value) == error_message def test_wrong_hash_variable(self): @@ -672,33 +672,33 @@ class TestNamespace: return {'dev': '123', 'name': '098'} ns = Namespace() - ns.addNamespace(Namespace("test")) - ns.test.addNamespace(Namespace("test2")) + ns.add_namespace(Namespace("test")) + ns.test.add_namespace(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)) + ns.test.test2.add_namespace(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") + ns0 = ns.add_namespace() + ns0.add_string_variable("test", "123") + ns1 = ns.add_namespace() + ns1.add_string_variable("test", "234") + ns2 = ns.add_namespace() + ns2.add_string_variable("test", "456") - assert [x.test.getValue() for x in ns] == ["123", "234", "456"] + assert [x.test.get_value() 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" + assert ns.level.level3.my_var1.get_value() == "testing" + assert ns.level.level3.myvar2.get_value() == "testing2" def test_variable_not_found(self): ns = Namespace() @@ -707,7 +707,7 @@ class TestNamespace: error_message = "Variable or namespace level.level3.myvar3 not found" with pytest.raises(VariableError) as e: - ns.level.level3.myvar3.getValue() + ns.level.level3.myvar3.get_value() assert str(e.value) == error_message # TODO: тест использует значения на конкретной машине @@ -716,13 +716,14 @@ class TestNamespace: # vl = VariableLoader() # vl.fill(ns, *VariableLoader.default()) # # нужно исправить тест, так - # # assert [x.name.getValue() for x in ns.os.gentoo.repositories] ==\ + # # assert [x.name.get_value() for x in ns.os.gentoo.repositories] ==\ # ["gentoo","distros","calculate","custom"] - # assert ns.os.gentoo.make_profile.getValue() ==\ + # assert ns.os.gentoo.make_profile.get_value() ==\ # "/etc/portage/make.profile" - # assert ns.os.gentoo.profile.path.getValue() ==\ + # assert ns.os.gentoo.profile.path.get_value() ==\ # "/var/db/repos/distros/profiles/CLD/amd64/20" - # assert ns.os.gentoo.profile.name.getValue() == "distros:CLD/amd64/20" + # assert ns.os.gentoo.profile.name.get_value() ==\ + # "distros:CLD/amd64/20" def test_profile_filler(self): ns = Namespace() @@ -742,37 +743,38 @@ class TestNamespace: 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.hashvar.value1.get_value() == "test1" + assert ns.os.hashvar.value2.get_value() == "test2" - assert ns.os.tablevar[0].dev.getValue() == "/dev/sdb1" - assert ns.os.tablevar[1].dev.getValue() == "/dev/sdb2" + assert ns.os.tablevar[0].dev.get_value() == "/dev/sdb1" + assert ns.os.tablevar[1].dev.get_value() == "/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.test.get_value() == "test" + assert ns.os.linux.arch.get_value() == "amd64" - assert ns.os.linux.title.getValue() == "Calculate Linux Desktop KDE 20" + assert ns.os.linux.title.get_value() ==\ + "Calculate Linux Desktop KDE 20" # Hash - assert ns.os.hashvar.value1.getValue() == "20" - assert ns.os.hashvar.value2.getValue() == "30" + assert ns.os.hashvar.value1.get_value() == "20" + assert ns.os.hashvar.value2.get_value() == "30" - ns.os.hashvar.value1.setValue("40") - assert ns.os.hashvar.value1.getValue() == "40" + ns.os.hashvar.value1.set_value("40") + assert ns.os.hashvar.value1.get_value() == "40" ns.os.hashvar.value1.invalidate() - assert ns.os.hashvar.value1.getValue() == "20" + assert ns.os.hashvar.value1.get_value() == "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" + assert ns.os.tablevar[0].dev.get_value() == "/dev/sda1" + assert ns.os.tablevar[1].dev.get_value() == "/dev/sda2" + assert ns.os.tablevar[2].dev.get_value() == "/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" + assert ns.os.tablevar[0].dev.get_value() == "/dev/sda1" + assert ns.os.tablevar[1].dev.get_value() == "/dev/sda2" + assert ns.os.tablevar[2].dev.get_value() == "/dev/sda5" def test_fill_namespace_by_module(self): pass @@ -782,4 +784,4 @@ class TestNamespace: # assert "os" in ns # assert "config" in ns.os.gentoo # assert "main" in ns - # assert ns.os.gentoo.config.getValue() is not None + # assert ns.os.gentoo.config.get_value() is not None diff --git a/tests/vars/variables/level/__init__.py b/tests/vars/variables/level/__init__.py index 0a0cc42..9ab6d7e 100644 --- a/tests/vars/variables/level/__init__.py +++ b/tests/vars/variables/level/__init__.py @@ -1,75 +1,90 @@ -from calculate.vars.datavars import Namespace, Variable, ChoiceVariable, ReadonlyVariable, ListVariable, HashVariable, TableVariable, ListVariable +from calculate.vars.datavars import Namespace, Variable, ChoiceVariable,\ + ReadonlyVariable, ListVariable,\ + HashVariable, TableVariable, ListVariable + class Simple(Variable): def get(self): return "simple value" + class Uselocalsimple(Variable): def get(self): - return "Using %s" % self.vars.simple.getValue(self) + return "Using %s" % self.vars.simple.get_value(self) + class Usefullsimple(Variable): def get(self): - return "Using %s" % self.vars.root.level.simple.getValue(self) + return "Using %s" % self.vars.root.level.simple.get_value(self) + class Badchoice(Variable): properties = [ChoiceVariable] + class Disks(Variable): properties = [ListVariable] def get(self): return ["/dev/sda1", "/dev/sda2", "/dev/sda3"] - def getComment(self): - mymap = {'/dev/sda1':'SWAP', - '/dev/sda2':'ROOT', - '/dev/sda3':'DATA'} - return [mymap.get(x) for x in self.getValue()] + def get_comment(self): + mymap = {'/dev/sda1': 'SWAP', + '/dev/sda2': 'ROOT', + '/dev/sda3': 'DATA'} + return [mymap.get(x) for x in self.get_value()] + class SimpleChoice(Variable): properties = [ChoiceVariable] def choice(self): - return self.vars.disks.getValue(self) + return self.vars.disks.get_value(self) + class CommentChoice(Variable): properties = [ChoiceVariable] - def choiceComment(self): - return list(zip(self.vars.disks.getValue(), - self.vars.disks.getComment())) + def choice_comment(self): + return list(zip(self.vars.disks.get_value(), + self.vars.disks.get_comment())) class Version(Variable): value = "1.0" + class Myshortname(Variable): value = "CLD" + class Linux(HashVariable): class Data(HashVariable.Data): def get(self): return { - 'ver':self.vars.version.getValue(self), - 'shortname':self.vars.myshortname.getValue(self) + 'ver': self.vars.version.get_value(self), + 'shortname': self.vars.myshortname.get_value(self) } class Test(Variable): def get(self): - return "my test - %s" % self.vars.ver.getValue(self) + return "my test - %s" % self.vars.ver.get_value(self) readonly_vars = ['shortname'] hash_vars = ["ver", "shortname"] + class ShortnameTest(Variable): def get(self): - return "{} test".format(self.vars.linux.shortname.getValue(self)) + return "{} test".format(self.vars.linux.shortname.get_value(self)) + class Devicelist(Variable): properties = [ListVariable] + def get(self): - return ["/dev/sda","/dev/sdb"] + return ["/dev/sda", "/dev/sdb"] + class Device(TableVariable): class Data(TableVariable.Data): @@ -79,18 +94,20 @@ class Device(TableVariable): '/dev/sdc': ["usbhdd", "WD 1TB"]} defaultValue = ["hdd", "Unknown"] return [ - {"dev":x, - "type":mapData.get(x,defaultValue)[0], - "name":mapData.get(x,defaultValue)[1]} - for x in self.vars.devicelist.getValue(self) + {"dev": x, + "type": mapData.get(x, defaultValue)[0], + "name": mapData.get(x, defaultValue)[1]} + for x in self.vars.devicelist.get_value(self) ] - hash_vars = ["dev","type","name"] + hash_vars = ["dev", "type", "name"] readonly_vars = ["name"] + class DeviceChild(Variable): def get(self): - return self.vars.device[0].type.getValue(self) + return self.vars.device[0].type.get_value(self) + class Level3(Namespace): class MyVar1(Variable): diff --git a/tests/vars/variables/level/level2/__init__.py b/tests/vars/variables/level/level2/__init__.py index f7df888..621bb16 100644 --- a/tests/vars/variables/level/level2/__init__.py +++ b/tests/vars/variables/level/level2/__init__.py @@ -1,5 +1,6 @@ from calculate.vars.datavars import Variable + class Vargetter(Variable): def get(self): - return "%s test" % self.vars.root.main.chroot.getValue(self) + return "%s test".format(self.vars.root.main.chroot.get_value(self)) diff --git a/tests/vars/variables/main/__init__.py b/tests/vars/variables/main/__init__.py index 820eb0c..70f5e0b 100644 --- a/tests/vars/variables/main/__init__.py +++ b/tests/vars/variables/main/__init__.py @@ -1,5 +1,6 @@ from calculate.vars.datavars import Variable, ReadonlyVariable + class Chroot(Variable): properties = [ReadonlyVariable] value = "/" diff --git a/tests/vars/variables/os/__init__.py b/tests/vars/variables/os/__init__.py index 59b46cf..2a57c00 100644 --- a/tests/vars/variables/os/__init__.py +++ b/tests/vars/variables/os/__init__.py @@ -22,14 +22,15 @@ class Linux(Namespace): class Title(Variable): def get(self): - subname = self.vars.subname.getValue(self) - fullname = self.vars.fullname.getValue(self) - ver = self.vars.ver.getValue(self) + subname = self.vars.subname.get_value(self) + fullname = self.vars.fullname.get_value(self) + ver = self.vars.ver.get_value(self) if subname: return "%s %s %s" % (fullname, subname, ver) else: return "%s %s" % (fullname, ver) + class Hashvar(HashVariable): class Data(HashVariable.Data): def get(self): @@ -41,12 +42,13 @@ class Hashvar(HashVariable): class Calculate(Variable): def get(self): return "%s %s" % ( - self.vars.value1.getValue(self), - self.vars.value2.getValue(self) + self.vars.value1.get_value(self), + self.vars.value2.get_value(self) ) hash_vars = ["value1", "value2"] - + + class Tablevar(TableVariable): class Data(TableVariable.Data): def get(self):