diff --git a/src/memory/memory.py b/src/memory/memory.py
index b48d5466..38a4c814 100644
--- a/src/memory/memory.py
+++ b/src/memory/memory.py
@@ -296,7 +296,7 @@ class Params(object):
return None
def updateParams(self, xml, security_limit=NO_SECURITY_LIMIT, app=''):
- """import xml in parameters, do nothing if the param already exist
+ """import xml in parameters, update if the param already exists
If security_limit is specified and greater than -1, the parameters
that have a security level greater than security_limit are skipped.
@param xml: parameters in xml form
@@ -339,7 +339,7 @@ class Params(object):
tgt_parent.appendChild(child)
else:
if child.nodeName == "param":
- # The child update an existing parameter, we replace the node
+ # The child updates an existing parameter, we replace the node
tgt_parent.replaceChild(child, node)
else:
# the node already exists, we recurse 1 more level
@@ -361,10 +361,11 @@ class Params(object):
warning(_("Trying to register frontends parameters with no specified app: aborted"))
return
if not hasattr(self, "frontends_cache"):
- self.frontends_cache = {}
+ self.frontends_cache = []
if app in self.frontends_cache:
- warning(_("Trying to register twice frontends parameters for %(app)s: aborted" % {"app": app}))
+ debug(_("Trying to register twice frontends parameters for %(app)s: aborted" % {"app": app}))
return
+ self.frontends_cache.append(app)
self.updateParams(xml, security_limit, app)
debug("Frontends parameters registered for %(app)s" % {'app': app})
diff --git a/src/test/constants.py b/src/test/constants.py
index c3bcea4d..2c00bc25 100644
--- a/src/test/constants.py
+++ b/src/test/constants.py
@@ -39,5 +39,6 @@ class Const(object):
# To test frontend parameters
APP_NAME = "dummy_frontend"
- ENABLE_UNIBOX_KEY = D_("Composition")
+ COMPOSITION_KEY = D_("Composition")
ENABLE_UNIBOX_PARAM = D_("Enable unibox")
+ PARAM_IN_QUOTES = D_("'Wysiwyg' edition")
diff --git a/src/test/helpers.py b/src/test/helpers.py
index c56f3b3c..5c7b09ed 100644
--- a/src/test/helpers.py
+++ b/src/test/helpers.py
@@ -240,6 +240,7 @@ class FakeMemory(Memory):
re-initialise the memory first to not fake the result."""
self.params.load_default_params()
self.params.params.clear()
+ self.params.frontends_cache = []
self.entities_data = {}
self.server_features = {}
diff --git a/src/test/test_memory_memory.py b/src/test/test_memory_memory.py
index 0fbeaa37..91502323 100644
--- a/src/test/test_memory_memory.py
+++ b/src/test/test_memory_memory.py
@@ -31,33 +31,41 @@ class MemoryTest(unittest.TestCase):
def setUp(self):
self.host = helpers.FakeSAT()
- def _getParamXML(self, name=None, category=None, security_level=None):
- if not name:
- name = Const.ENABLE_UNIBOX_PARAM
- if not category:
- category = Const.ENABLE_UNIBOX_KEY
+ def _getParamXML(self, param="1", security_level=None):
+ def getParam(name):
+ return """
+
+ """ % {'param_name': name,
+ 'param_label': _(name),
+ 'security': '' if security_level is None else ('security="%d"' % security_level)
+ }
+ if param == "1":
+ params = getParam(Const.ENABLE_UNIBOX_PARAM)
+ elif param == "2":
+ params = getParam(Const.PARAM_IN_QUOTES)
+ else:
+ params = getParam(Const.ENABLE_UNIBOX_PARAM) + getParam(Const.PARAM_IN_QUOTES)
return """
-
+ %(params)s
""" % {
- 'category_name': category,
- 'category_label': _(category),
- 'param_name': name,
- 'param_label': _(name),
- 'security': '' if security_level is None else ('security="%d"' % security_level)
+ 'category_name': Const.COMPOSITION_KEY,
+ 'category_label': _(Const.COMPOSITION_KEY),
+ 'params': params
}
- def _paramExists(self, name=None, category=None, src=None):
+ def _paramExists(self, param="1", src=None):
"""@return: True is the param (category, name) exists"""
- if not name:
+ if param == "1":
name = Const.ENABLE_UNIBOX_PARAM
- if not category:
- category = Const.ENABLE_UNIBOX_KEY
+ else:
+ name = Const.PARAM_IN_QUOTES
+ category = Const.COMPOSITION_KEY
if src is None:
src = self.host.memory.params.dom.documentElement
for type_node in src.childNodes:
@@ -74,28 +82,28 @@ class MemoryTest(unittest.TestCase):
return True
return False
- def assertParam_generic(self, src=None, exists=True, deferred=False):
+ def assertParam_generic(self, param="1", src=None, exists=True, deferred=False):
msg = "Expected parameter not found!\n" if exists else "Unexpected parameter found!\n"
if deferred == False:
# in this stack we can see the line where the error came from,
# if limit=5, 6 is not enough you can increase the value
msg += "\n".join(traceback.format_stack(limit=5 if exists else 6))
- assertion = self._paramExists(src=src)
+ assertion = self._paramExists(param, src)
getattr(self, "assert%s" % exists)(assertion, msg)
- def assertParamExists(self, src=None):
- self.assertParam_generic(src, True)
+ def assertParamExists(self, param="1", src=None):
+ self.assertParam_generic(param, src, True)
- def assertParamNotExists(self, src=None):
- self.assertParam_generic(src, False)
+ def assertParamNotExists(self, param="1", src=None):
+ self.assertParam_generic(param, src, False)
- def assertParamExists_async(self, src):
+ def assertParamExists_async(self, src, param="1"):
"""@param src: a deferred result from Memory.getParams"""
- self.assertParam_generic(minidom.parseString(src.encode("utf-8")), True, True)
+ self.assertParam_generic(param, minidom.parseString(src.encode("utf-8")), True, True)
- def assertParamNotExists_async(self, src):
+ def assertParamNotExists_async(self, src, param="1"):
"""@param src: a deferred result from Memory.getParams"""
- self.assertParam_generic(minidom.parseString(src.encode("utf-8")), False, True)
+ self.assertParam_generic(param, minidom.parseString(src.encode("utf-8")), False, True)
def _getParams(self, security_limit, app='', profile_key='@NONE@'):
if profile_key == '@NONE@':
@@ -112,6 +120,29 @@ class MemoryTest(unittest.TestCase):
self.host.memory.updateParams(self._getParamXML())
self.assertEqual(previous.toxml().encode("utf-8"), self.host.memory.params.dom.toxml().encode("utf-8"))
+ self.host.memory.init()
+ # check successive updates (without intersection)
+ self.host.memory.updateParams(self._getParamXML('1'))
+ self.assertParamExists("1")
+ self.assertParamNotExists("2")
+ self.host.memory.updateParams(self._getParamXML('2'))
+ self.assertParamExists("1")
+ self.assertParamExists("2")
+
+ previous = self.host.memory.params.dom.cloneNode(True) # save for later
+
+ self.host.memory.init()
+ # check successive updates (with intersection)
+ self.host.memory.updateParams(self._getParamXML('1'))
+ self.assertParamExists("1")
+ self.assertParamNotExists("2")
+ self.host.memory.updateParams(self._getParamXML('both'))
+ self.assertParamExists("1")
+ self.assertParamExists("2")
+
+ # successive updates with or without intersection should have the same result
+ self.assertEqual(previous.toxml().encode("utf-8"), self.host.memory.params.dom.toxml().encode("utf-8"))
+
def test_getParams(self):
# tests with no security level on the parameter (most secure)
params = self._getParamXML()
@@ -155,6 +186,7 @@ class MemoryTest(unittest.TestCase):
self.host.memory.init()
register(params, 1, Const.APP_NAME)
self.assertParamNotExists()
+
# tests with security level 0 on the parameter (not secure)
params = self._getParamXML(security_level=0)
self.host.memory.init()
@@ -166,6 +198,7 @@ class MemoryTest(unittest.TestCase):
self.host.memory.init()
register(params, 1, Const.APP_NAME)
self.assertParamExists()
+
# tests with security level 1 on the parameter (more secure)
params = self._getParamXML(security_level=1)
self.host.memory.init()