erebion/libervia-backend
Watch
1
0
Fork
You've already forked libervia-backend
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

test: use the SatTestCase methods instead of builtin "assert" in tests for memory, plugin xep-0033

Browse source
This commit is contained in:
souliane 2014-01-07 09:27:53 +01:00
commit 6be767ae3b
1 changed files with 73 additions and 62 deletions
Download patch file Download diff file Expand all files Collapse all files

78
src/test/test_memory.py
View file

@ -73,24 +73,28 @@ class MemoryTest(unittest.TestCase):
return True
return False
def _assert(self, src, true=True):
"""@param src: a deferred result from Memory.getParams"""
assertion = self._paramExists(src=minidom.parseString(src.encode("utf-8")))
if not true:
assertion = not assertion
try:
assert(assertion)
except AssertionError as e:
def assertParam_generic(self, 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 is not enough you can increase the value
print "---------------------- stack start ----------------------"
traceback.print_stack(limit=5 if true else 6)
print "----------------------- stack end -----------------------"
raise e
# 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)
getattr(self, "assert%s" % exists)(assertion, msg)
def _assert_not(self, src):
def assertParamExists(self, src=None):
self.assertParam_generic(src, True)
def assertParamNotExists(self, src=None):
self.assertParam_generic(src, False)
def assertParamExists_async(self, src):
"""@param src: a deferred result from Memory.getParams"""
self._assert(src, False)
self.assertParam_generic(minidom.parseString(src.encode("utf-8")), True, True)
def assertParamNotExists_async(self, src):
"""@param src: a deferred result from Memory.getParams"""
self.assertParam_generic(minidom.parseString(src.encode("utf-8")), False, True)
def _getParams(self, security_limit, app='', profile_key='@NONE@'):
if profile_key == '@NONE@':
@ -101,7 +105,7 @@ class MemoryTest(unittest.TestCase):
self.host.memory.init()
# check if the update works
self.host.memory.updateParams(self._getParamXML())
assert(self._paramExists())
self.assertParamExists()
previous = self.host.memory.params.dom.cloneNode(True)
# now check if it is really updated and not duplicated
self.host.memory.updateParams(self._getParamXML())
@ -112,64 +116,64 @@ class MemoryTest(unittest.TestCase):
params = self._getParamXML()
self.host.memory.init()
self.host.memory.updateParams(params)
self._getParams(Const.NO_SECURITY_LIMIT).addCallback(self._assert)
self._getParams(0).addCallback(self._assert_not)
self._getParams(1).addCallback(self._assert_not)
self._getParams(Const.NO_SECURITY_LIMIT).addCallback(self.assertParamExists_async)
self._getParams(0).addCallback(self.assertParamNotExists_async)
self._getParams(1).addCallback(self.assertParamNotExists_async)
# tests with security level 0 on the parameter (not secure)
params = self._getParamXML(security_level=0)
self.host.memory.init()
self.host.memory.updateParams(params)
self._getParams(Const.NO_SECURITY_LIMIT).addCallback(self._assert)
self._getParams(0).addCallback(self._assert)
self._getParams(1).addCallback(self._assert)
self._getParams(Const.NO_SECURITY_LIMIT).addCallback(self.assertParamExists_async)
self._getParams(0).addCallback(self.assertParamExists_async)
self._getParams(1).addCallback(self.assertParamExists_async)
# tests with security level 1 on the parameter (more secure)
params = self._getParamXML(security_level=1)
self.host.memory.init()
self.host.memory.updateParams(params)
self._getParams(Const.NO_SECURITY_LIMIT).addCallback(self._assert)
self._getParams(0).addCallback(self._assert_not)
self._getParams(1).addCallback(self._assert)
self._getParams(Const.NO_SECURITY_LIMIT).addCallback(self.assertParamExists_async)
self._getParams(0).addCallback(self.assertParamNotExists_async)
self._getParams(1).addCallback(self.assertParamExists_async)
def test_paramsRegisterApp(self):
# tests with no security level on the parameter (most secure)
params = self._getParamXML()
self.host.memory.init()
self.host.memory.paramsRegisterApp(params, Const.NO_SECURITY_LIMIT, Const.APP_NAME)
assert(self._paramExists())
self.assertParamExists()
self.host.memory.init()
self.host.memory.paramsRegisterApp(params, 0, Const.APP_NAME)
assert(not self._paramExists())
self.assertParamNotExists()
self.host.memory.init()
self.host.memory.paramsRegisterApp(params, 1, Const.APP_NAME)
assert(not self._paramExists())
self.assertParamNotExists()
# tests with security level 0 on the parameter (not secure)
params = self._getParamXML(security_level=0)
self.host.memory.init()
self.host.memory.paramsRegisterApp(params, Const.NO_SECURITY_LIMIT, Const.APP_NAME)
assert(self._paramExists())
self.assertParamExists()
self.host.memory.init()
self.host.memory.paramsRegisterApp(params, 0, Const.APP_NAME)
assert(self._paramExists())
self.assertParamExists()
self.host.memory.init()
self.host.memory.paramsRegisterApp(params, 1, Const.APP_NAME)
assert(self._paramExists())
self.assertParamExists()
# tests with security level 1 on the parameter (more secure)
params = self._getParamXML(security_level=1)
self.host.memory.init()
self.host.memory.paramsRegisterApp(params, Const.NO_SECURITY_LIMIT, Const.APP_NAME)
assert(self._paramExists())
self.assertParamExists()
self.host.memory.init()
self.host.memory.paramsRegisterApp(params, 0, Const.APP_NAME)
assert(not self._paramExists())
self.assertParamNotExists()
self.host.memory.init()
self.host.memory.paramsRegisterApp(params, 1, Const.APP_NAME)
assert(self._paramExists())
self.assertParamExists()
def test_paramsRegisterApp_getParams(self):
# test retrieving the parameter for a specific frontend
self.host.memory.init()
params = self._getParamXML(security_level=1)
self.host.memory.paramsRegisterApp(params, 1, Const.APP_NAME)
self._getParams(1, '').addCallback(self._assert)
self._getParams(1, Const.APP_NAME).addCallback(self._assert)
self._getParams(1, 'another_dummy_frontend').addCallback(self._assert_not)
self._getParams(1, '').addCallback(self.assertParamExists_async)
self._getParams(1, Const.APP_NAME).addCallback(self.assertParamExists_async)
self._getParams(1, 'another_dummy_frontend').addCallback(self.assertParamNotExists_async)