Slave.py

Go to the documentation of this file.

#
# Copyright 2007, MeVis Medical Solutions AG
#
# The user may use this file in accordance with the license agreement provided with
# the Software or, alternatively, in accordance with the terms contained in a
# written agreement between the user and MeVis Medical Solutions AG.
#
# For further information use the contact form at https://www.mevislab.de/contact
#
 
 
 
# -- system imports ----------------------------------------------------------------------------{{{-
import os
import re
import traceback
 
import sys
 
if sys.version_info.major >= 3:
    unicode = str
 
import xml.etree.cElementTree as etree
 
# ----------------------------------------------------------------------------------------------}}}-
 
# -- local imports -----------------------------------------------------------------------------{{{-
import mevis
import PackageSorter
 
from . import IPC
from . import Config
from . import Utils
from .LogHandler import LogHandler
from TestSupport.TestHelper import TestHelper
 
from .TestCaseGeneric import GenericTestCase
from .TestCaseFunctional import FunctionalTestCase
import TestSupport
 
from . import CodeCoverage
from .CodeTestSupport import getCodeTest, getCodeTestsByPackage, CodeTestTestCase
 
# ----------------------------------------------------------------------------------------------}}}-
 
# Determine if the Standard SDK FME modules are available:
_isPublicSDK = bool(
    mevis.MLABPackageManager.packagesByGroup("FMEstable") and mevis.MLABPackageManager.packagesByGroup("FMEwork")
)
 
 
# ----------------------------------------------------------------------------------------------}}}-
class TestCaseRemoteListener:
 
    def __init__(self, com):
        self.stopped = False
        self.__com = com
 
    def startTestCaseFunction(self, testType, testCase, testFunction):
        resultNode = etree.Element("Progress")
        resultNode.set("testType", testType)
        resultNode.set("testCase", testCase)
        resultNode.set("testFunction", testFunction)
        if not self.__com.send(etree.tostring(resultNode), 5):
            mevis.MLAB.logError("Couldn't send progress")
            raise TestSupport.TestHelper.CancelTestException
        # receive the result, if it is "0", we are supposed to stop,
        # otherwise we can continue
        result = self.__com.recv(5)
        if result == "0":
            raise TestSupport.TestHelper.CancelTestException
 
    def endTestCaseFunction(self, status, duration):
        resultNode = etree.Element("Status")
        resultNode.set("status", str(status))
        if not self.__com.send(etree.tostring(resultNode), 5):
            mevis.MLAB.logError("Couldn't send status")
            raise TestSupport.TestHelper.CancelTestException
 
 
# -- class Slave -------------------------------------------------------------------------------{{{-
 
class Slave:
    # -- member variables ------------------------------------------------------------------------{{{-
    
    __ctx = None
    
    __com = None
 
    
    __testCase = None
 
    
    __running = None
 
    
    __testCfg = None
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __init__ ----------------------------------------------------------------------------{{{-
    
    def __init__(self, cfgFile, context, offline=False):
        self.__ctx = context
        self.__com = IPC.ComSlave() if not offline else None
 
        self.__testCaseListener = None
        self.__agendaTestCase = None
        self.__isInsideTestCaseManager = False
 
        # The current configuration
        self._config = Config.Configuration(cfgFile)
 
        # Create result directory if not available.
        resultDir = self._config.getResultDir()
        if not os.path.isdir(resultDir):
            os.makedirs(resultDir)
 
        # Set new logfile to use. This is required as there could be multiple
        # MeVisLab instances writing to the same logfile what would make crash
        # handling impossible.
        self.__logfile = self._config.getSlaveLogFilePath()
 
        # Load test cases if not done already.
        if not mevis.MLABTestCaseDatabase.areTestCasesLoaded():
            mevis.MLABTestCaseDatabase.loadTestCases()
 
        # Initialize the test helper singleton.
        TestHelper.getInstance(context=self.__ctx, resultDir=self._config.getResultDir())
 
    # --------------------------------------------------------------------------------------------}}}-
 
    def setIsInsideTestCaseManager(self, isInsideTestCaseManager):
        self.__isInsideTestCaseManager = isInsideTestCaseManager
 
    def setTestCaseListener(self, listener):
        self.__testCaseListener = listener
 
    # -- def loadTestCase ------------------------------------------------------------------------{{{-
    
    def loadTestCase(self, testCaseNode):
        testType = testCaseNode.get("type")
        moduleName = testCaseNode.get("module") if testType == "GenericTestCase" else None
        return self.__loadTestCase(testCaseNode.get("name"), testType, moduleName)
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __loadTestCase ----------------------------------------------------------------------{{{-
    
    def __loadTestCase(self, testCaseName, testCaseType, moduleName=None):
        # Create test case depending on the type.
        if testCaseType == "GenericTestCase":
            testCase = GenericTestCase(testCaseName, moduleName)
        elif testCaseType == "FunctionalTestCase":
            testCase = FunctionalTestCase(testCaseName)
        elif testCaseType == "CodeTestTestCase":
            testCase = CodeTestTestCase(testCaseName)
        else:
            raise Exception("Unsupported test case type %s" % testCaseType)
        return testCase
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def setAgendaTestCase -------------------------------------------------------------------------{{{-
    
    def setAgendaTestCase(self, testCase):
        self.__agendaTestCase = testCase
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def getTestCase -------------------------------------------------------------------------{{{-
    
    def getTestCase(self):
        return self.__testCase
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def unloadTestCase -------------------------------------------------------------------------{{{-
    
    def unloadTestCase(self):
        self.__testCase = None
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __doTest ----------------------------------------------------------------------------{{{-
    
 
    def __doTest(self, testCaseNode, resultNode):
 
        try:
            maxErrorMessagesPerTestFunction = int(testCaseNode.get("maxErrorMessagesPerTestFunction"))
        except:
            maxErrorMessagesPerTestFunction = 10000
        try:
            maxInfoMessagesPerTestFunction = int(testCaseNode.get("maxInfoMessagesPerTestFunction"))
        except:
            maxInfoMessagesPerTestFunction = 10000
 
        # clear encoding cache for each test to prevent it from containing outdated encoding data
        TestSupport.Base.clearEncodingCache()
 
        # start coverage right in front of loading, since some code parts are only
        # traversed during the loading phase of a test case. Those
        # are mainly function definitions etc.
        try:
            pythonCoverage = CodeCoverage.PythonCoverage(config=self._config, testCaseNode=testCaseNode)
        except CodeCoverage.CoverageException as e:
            pythonCoverage = None
            mevis.MLAB.logError(e)
 
        try:
            bullseyeCoverage = CodeCoverage.BullseyeCoverage(config=self._config, testCaseNode=testCaseNode)
        except CodeCoverage.CoverageException as e:
            bullseyeCoverage = None
            mevis.MLAB.logError(e)
 
        self.__testCase = self.loadTestCase(testCaseNode)
 
        # Run the test case only if it loaded correctly.
        if self.__testCase:
            # Do NOT run test, when status is TEST_STATUS_DO_NOT_TEST_MODULE. Only relevant for GenericTests
            if not testCaseNode.get("status") == Utils.TEST_STATUS_DO_NOT_TEST_MODULE:
                if pythonCoverage and pythonCoverage.isRunning():
                    # store the target file in a subNode so the HTML creation process knows there
                    # were coverage results for this test.
                    resultNode.set("pythonCoverage", pythonCoverage.getCoverageBinaryFilePath())
 
                if bullseyeCoverage and bullseyeCoverage.isRunning():
                    # store the target file in a subNode so the HTML creation process knows there
                    # were coverage results for this test.
                    resultNode.set("bullseyeCoverage", bullseyeCoverage.getCoverageBinaryFilePath())
 
                logHandler = LogHandler(self.__logfile)
                logHandler.setErrorLimit(maxErrorMessagesPerTestFunction)
                logHandler.setInfoLimit(maxInfoMessagesPerTestFunction)
                TestHelper.getInstance().setLogHandler(logHandler)
 
                mevis.MLAB.priv().connect("loggingMessage(const QString&)", logHandler.appendMessage)
                mevis.MLAB.priv().aboutToLogMessage.connect(logHandler.aboutToLogMessage)
                mevis.MLAB.priv().startLogCollect()
                self.__testCase.setTestCaseListener(self.__testCaseListener)
                self.__testCase.run(testCaseNode)
 
                mevis.MLAB.priv().stopLogCollect()
                mevis.MLAB.priv().disconnect("loggingMessage(const QString&)", logHandler.appendMessage)
                mevis.MLAB.priv().aboutToLogMessage.disconnect(logHandler.aboutToLogMessage)
 
                TestHelper.getInstance().unsetLogHandler()
                logHandler.close()
 
            resultNode.set("errorCode", "Ok")
            # Append results to the resultNode.
            resultNode.append(testCaseNode)
        else:
            resultNode.set("errorCode", "TestCaseError")
            etree.SubElement(resultNode, "Error").text = "Unknown test case (%s)." % (testCaseNode.get("name"))
 
        if pythonCoverage:
            pythonCoverage.stop()
 
        if bullseyeCoverage:
            try:
                bullseyeCoverage.stop()
            except CodeCoverage.CoverageException as e:
                mevis.MLAB.logError(e)
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __buildTestAgenda -------------------------------------------------------------------{{{-
    
    def __buildTestAgenda(self, testCfg, resultNode):
 
        def ___addPackageInfoNode(rootNode):
            packageInfoNode = etree.SubElement(rootNode, "PackageSortingInReport")
            packageInfoNode.set(
                "PackagesByNumberOfDependencies", ",".join(PackageSorter.byNumberOfDependencies.packages)
            )
            packageInfoNode.set(
                "PackageGroupsByNumberOfDependencies", ",".join(PackageSorter.byNumberOfDependencies.packageGroups)
            )
 
        testRunNode = etree.Element("TestRun")
 
        # An internal data structure with easier access than the XML structure.
        self.__testCfg = {
            "Packages": {"Tested": [], "Available": []},
            "TestGroups": [],
            "TestSuites": [],
            "Modules": [],
        }
 
        # Consolidate the information on the packages available.
        self.__verifyPackages(testCfg)
 
        # Get information on the test groups selected.
        for testGroupNode in testCfg.findall("TestGroups/TestGroup"):
            self.__testCfg["TestGroups"].append(testGroupNode.get("name"))
 
        # Add the test cases from given test suites to the TestCases node
        for testSuiteNode in testCfg.findall("TestSuites/TestSuite"):
            testSuite = testSuiteNode.get("name")
            testCaseNames = mevis.MLABTestCaseDatabase.allTestCaseSuites().get(testSuite, {}).get("testCases", [])
            testCasesNode = testCfg.find("TestCases")
            for name in testCaseNames:
                etree.SubElement(testCasesNode, "TestCase", {"name": name})
 
        # Set system information.
        testRunNode.set("platform", mevis.MLAB.systemId())
        testRunNode.set("compiler", mevis.MLAB.compilerInfo())
        # Set build information.
        testRunNode.set("builddate", mevis.MLAB.dateOfBuildJob().date().toString("yyyy-MM-dd"))
        testRunNode.set("version", mevis.MLAB.priv().variable("Version", False))
 
        # Create nodes to store information on the test run.
        infoNode = etree.SubElement(testRunNode, "Information")
        testResultNode = etree.SubElement(testRunNode, "Results")
        etree.SubElement(infoNode, "TestCases")
        etree.SubElement(infoNode, "Modules")
        ___addPackageInfoNode(infoNode)
 
        # Consolidate the information on the test cases that should be executed.
        self.__verifyTestCaseList(testCfg, testRunNode)
 
        # If no generic test cases are used then don't build information list for
        # modules (this causes major performance on windows machines when storing
        # the resulting xml).
        for testCaseNode in infoNode.findall("./TestCases/TestCase"):
            if testCaseNode.get("type") == "GenericTestCase":
                # extend the XML structure and hook in all modules to test
                self.__collectModulesToTest(testCfg)
                self.__buildModuleInfo(infoNode.find("Modules"))
                break
 
        resultNode.set("errorCode", "Ok")
        resultNode.append(testRunNode)
        resultNode.append(testCfg)
 
        self.__testCfg = None
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __buildTestCaseAgenda ---------------------------------------------------------------{{{-
    def __buildTestCaseAgenda(self, requestNode, resultNode):
        try:
            parameterNode = requestNode.find("Parameters")
            packagesToTest = parameterNode.get("packages", "").split(",")
            modulesToTest = parameterNode.get("modules", "").split(",")
            testCaseName = parameterNode.find("TestCase").get("name")
            testResultsNode = etree.SubElement(resultNode, "Results")
            testCaseAgenda, status = self.__loadAndVerifyTestCase(
                testCaseName, testResultsNode, packagesToTest, modulesToTest
            )
            testCase = testResultsNode.find("TestCase")
            # Remove TestFunctions for GenericTests with status TEST_STATUS_DO_NOT_TEST_MODULE.
            if testCase is not None and testCase.get("status", "") == str(Utils.TEST_STATUS_DO_NOT_TEST_MODULE):
                functionListNode = testCaseAgenda.find("TestFunctions")
                functionNodes = functionListNode.findall("Function")
                for functionNode in functionNodes:
                    functionListNode.remove(functionNode)
            assert testCaseAgenda
            resultNode.append(testCaseAgenda)
            if status != "Ok":
                etree.SubElement(resultNode, "Error").text = "Failed to load the test case"
            resultNode.set("errorCode", status)
        except:
            resultNode.set("errorCode", "Failed")
            etree.SubElement(resultNode, "Error").text = traceback.format_exc()
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __verifyTestCaseList ----------------------------------------------------------------{{{-
    
    def __verifyTestCaseList(self, testCfg, testRunNode):
        # Get list of all available test cases.
        availTestCaseList = []
        for package in self.__testCfg["Packages"]["Tested"]:
            availTestCaseList.extend(mevis.MLABTestCaseDatabase.allTestCasesForPackage(package))
            if self.__isInsideTestCaseManager:
                availTestCaseList.extend(getCodeTestsByPackage().get(package, {}).keys())
 
        # If no test cases were given use list of available ones.
        testCaseListNode = testCfg.find("TestCases")
        if len(testCaseListNode.findall("TestCase")) == 0:
            for testCaseName in availTestCaseList:
                etree.SubElement(testCaseListNode, "TestCase", name=testCaseName)
 
        # Get the node to append information to.
        testInfoNode = testRunNode.find("Information/TestCases")
 
        for testCaseNode in testCfg.findall("TestCases/TestCase"):
            testCaseName = testCaseNode.get("name")
            if testCaseName in availTestCaseList:
                infoDict = self.__getTestCaseInfo(testCaseName)
                # Verify test groups if necessary.
                if not self.__verifyTestGroups(infoDict, self.__testCfg["TestGroups"]):
                    mevis.MLAB.logError(
                        "TestCase %s not in tested groups (%s)."
                        % (testCaseName, ", ".join(self.__testCfg["TestGroups"]))
                    )
                    testCaseNode.set("isNotInTestGroups", str(True))
                else:
                    testCaseNode.set("type", infoDict["type"])
                    testInfoNode.append(testCaseNode)
                    testCaseNode.set("status", str(Utils.TEST_STATUS_OK))
            else:
                mevis.MLAB.logError("test case not found %s %s" % (testCaseName, availTestCaseList))
                testCaseNode.set("status", str(Utils.TEST_STATUS_ERROR))
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __verifyTestCase --------------------------------------------------------------------{{{-
    
    def __loadAndVerifyTestCase(self, testCaseName, testResultNode, packagesToTest, modulesToTest):
        resolvedPackagesToTest = []
        for package in packagesToTest:
            pGroup, pName = package.split("/")
            if pGroup == "*" and pName == "*":
                for package in mevis.MLABPackageManager.packages():
                    resolvedPackagesToTest.append(package.packageIdentifier())
            elif pName == "*":
                for package in mevis.MLABPackageManager.packages():
                    if package.packageGroup() == pGroup:
                        resolvedPackagesToTest.append(package.packageIdentifier())
            else:
                resolvedPackagesToTest.append(package)
        testCaseNode, status = self.__verifyTestCase(
            testCaseName, testResultNode, resolvedPackagesToTest, modulesToTest
        )
        return testCaseNode, status
 
    # --------------------------------------------------------------------------------------------}}}-
 
    def __getTestCaseInfo(self, testCaseName):
        infoDict = mevis.MLABTestCaseDatabase.testCaseInfo(testCaseName)
        if not infoDict:
            codeTest = getCodeTest(testCaseName)
            if codeTest != None:
                infoDict = codeTest.getInfoDict()
        return infoDict
 
    # -- def __verifyTestCase --------------------------------------------------------------------{{{-
    
    def __verifyTestCase(self, testCaseName, testResultNode, packagesToTest, modulesToTest):
        infoDict = self.__getTestCaseInfo(testCaseName)
 
        # Try to load the test case.
        testType = infoDict["type"]
 
        # if agenda test case is set from outside, use it
        testCase = self.__agendaTestCase
        if not testCase:
            mevis.MLAB.log("Trying to load test case %s" % testCaseName)
            # no test case set, try loading it instead
            testCase = self.__loadTestCase(testCaseName, testType)
            mevis.MLAB.log("Loading complete")
 
        if testCase == None:
            return None, "Failed"
 
            # Add basic information for the actual testing.
        if testType == "GenericTestCase":
            modulesToTest, modulesNotToTest = testCase.getModulesToTest(modulesToTest, packagesToTest)
            for moduleName in modulesToTest:
                etree.SubElement(testResultNode, "TestCase", name=testCaseName, type=testType, module=moduleName)
            for moduleName in modulesNotToTest:
                etree.SubElement(
                    testResultNode,
                    "TestCase",
                    name=testCaseName,
                    type=testType,
                    module=moduleName,
                    status=str(Utils.TEST_STATUS_DO_NOT_TEST_MODULE),
                )
        else:
            etree.SubElement(testResultNode, "TestCase", name=testCaseName, type=testType)
 
        return testCase.getTestCaseNode(), "Ok"
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __verifyTestGroups ------------------------------------------------------------------{{{-
    
    def __verifyTestGroups(self, infoDict, testGroupList):
        testCaseGroupList = infoDict["testGroups"].lower() if "testGroups" in infoDict else ""
        testCaseGroupList = testCaseGroupList.split()
 
        if "disabled" in testCaseGroupList or ("needspublicsdk" in testCaseGroupList and not _isPublicSDK):
            return False
        testGroupList = [tg.lower() for tg in testGroupList]
        if testGroupList:
            if "automatic" in testGroupList:
                if "manual" in testCaseGroupList:
                    return False
                return True
            for testGroup in testGroupList:
                if testGroup in testCaseGroupList:
                    return True
            return False
        return True
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __verifyPackages --------------------------------------------------------------------{{{-
    
    def __verifyPackages(self, testCfg):
        packageRoot = testCfg.find("Packages")
 
        # First go over list and substitute wildcards and verify all given
        # packages.
        tPkgNode = packageRoot.find("Tested")
        aPkgNode = packageRoot.find("Available")
        iPkgNode = packageRoot.find("Ignored")
        # if no ignored package is given,
        # then self.__verifyPackageListNode() would ignore all packages
        if len(iPkgNode) > 0:
            self.__verifyPackageListNode(iPkgNode)
        ignoredPackageIDs = set()
        for ignoredPackage in iPkgNode:
            ignoredPackageIDs.add(ignoredPackage.get("name"))
 
        self.__verifyPackageListNode(tPkgNode, ignoredPackageIDs)
        self.__verifyPackageListNode(aPkgNode, ignoredPackageIDs)
        # Get list of verified packages.
        tPkgSet = set()
        for packageNode in tPkgNode.findall("Package"):
            if packageNode.get("status") in ("Ok", "Added"):
                tPkgSet.add(packageNode.get("name"))
 
        aPkgSet = set()
        for packageNode in aPkgNode.findall("Package"):
            if packageNode.get("status") in ("Ok", "Added"):
                aPkgSet.add(packageNode.get("name"))
 
        # Save lists of packages sets for usage on slave side.
        self.__testCfg["Packages"]["Tested"] = list(tPkgSet)
        self.__testCfg["Packages"]["Available"] = list(tPkgSet.union(aPkgSet))
 
        # Add all available packages for usage on master side.
        for item in tPkgSet.difference(aPkgSet):
            etree.SubElement(aPkgNode, "Package", name=item, status="Ok")
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __verifyPackageListNode -------------------------------------------------------------{{{-
    
    def __verifyPackageListNode(self, packageListNode, ignoredPackageIDs=[]):
        # If no packages are given add everything!
        if len(packageListNode) == 0:
            etree.SubElement(packageListNode, "Package", name="*/*")
 
        for packageNode in packageListNode:
            packageID = packageNode.get("name")
            try:
                pGroup, pName = packageID.split("/")
            except:
                packageNode.set("status", "Invalid")
                continue
 
            # Substitute the wildcards.
            if pGroup == "*":
                if pName == "*":
                    for package in mevis.MLABPackageManager.packages():
                        packageID = package.packageIdentifier()
                        if not packageID in ignoredPackageIDs:
                            etree.SubElement(packageListNode, "Package", name=packageID, status="Added")
                    # Remove node as the wildcard has been executed.
                    packageNode.set("status", "Substituted")
                else:
                    packageNode.set("status", "Failed")
            elif pName == "*":
                packageNode.set("status", "Substituted")
                for package in mevis.MLABPackageManager.packagesByGroup(pGroup):
                    packageID = package.packageIdentifier()
                    if not packageID in ignoredPackageIDs:
                        etree.SubElement(packageListNode, "Package", name=packageID, status="Added")
            else:
                # If the given package exists add it to the package set otherwise
                # remove the XML node.
                if mevis.MLABPackageManager.packageByIdentifier(packageID):
                    packageNode.set("status", "Ok")
                else:
                    packageNode.set("status", "Failed")
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __collectModulesToTest ---------------------------------------------------------------------{{{-
    
    def __collectModulesToTest(self, testCfg):
        modulesNode = testCfg.find("Modules")
 
        # Build up a dictionary with all specified filters.
        filterDict = {}
        for filterNode in modulesNode.findall("Filter"):
            key, valueList = filterNode.text.split(":")
            filterDict[key] = []
            for value in valueList.split(","):
                filterDict[key].append(value)
 
        # Build up a list with all modules to be be taken into account.
        availableModuleList = []
        for packageName in self.__testCfg["Packages"]["Tested"]:
            availableModuleList.extend(mevis.MLAB.allModulesForPackageIdentifier(packageName))
 
        # If the user did not specify a list of modules use all available.
        if len(modulesNode.findall("Module")) == 0:
            for moduleName in availableModuleList:
                etree.SubElement(modulesNode, "Module", name=moduleName)
 
        # Find all modules to test.
        for moduleNode in modulesNode.findall("Module"):
            moduleName = moduleNode.get("name")
            moduleInfo = mevis.MLAB.moduleInfo(moduleName)
 
            if moduleInfo and moduleName in availableModuleList:
                useModule = True
                # Does module pass filters?
                for f in filterDict:
                    if not f in moduleInfo or not [x for x in filterDict[f] if re.search(x, moduleInfo[f])]:
                        useModule = False
                        break
                if useModule:
                    self.__testCfg["Modules"].append(moduleName)
                    moduleNode.set("status", str(Utils.TEST_STATUS_OK))
                else:
                    moduleNode.set("isModuleFiltered", str(True))
            else:
                modulesNode.set("status", str(Utils.TEST_STATUS_ERROR))
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __buildModuleInfo -------------------------------------------------------------------{{{-
    #  @param modulesInfoNode XML node taking the module information.
    def __buildModuleInfo(self, modulesInfoNode):
        for moduleName in self.__testCfg["Modules"]:
            moduleInfo = mevis.MLAB.moduleInfo(moduleName)
            newModuleNode = etree.SubElement(modulesInfoNode, "Module", name=moduleName)
            for key in moduleInfo:
                value = moduleInfo[key]
                etree.SubElement(newModuleNode, key, type=value.__class__.__name__).text = unicode(value)
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def __setPackageList --------------------------------------------------------------------{{{-
    
    def __setPackageList(self, xmlNode, resultNode):
        packageList = []
        for item in xmlNode.findall("Package"):
            packageList.append(item.get("name"))
        TestHelper.getInstance().setPackageList(packageList)
        resultNode.set("errorCode", "Ok")
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def runCommand --------------------------------------------------------------------------{{{-
    
    def runCommand(self, requestNode):
        resultNode = etree.Element("Result")
        if not TestHelper.getInstance().getGlobalContext():
            command = "Quit"
            mevis.MLAB.logWarning("Test case manager has been closed - aborting test execution")
        else:
            command = requestNode.get("type")
            mevis.MLAB.log("Running command '%s'" % command)
 
        try:
            if command == "Quit":
                resultNode.set("errorCode", "Ok")
                self.__running = False
            elif command == "DoTest":
                testCaseNode = requestNode.find("TestCase")
                if self.__com and testCaseNode.get("requestProgress") == "1":
                    self.setTestCaseListener(TestCaseRemoteListener(self.__com))
 
                self.__doTest(testCaseNode, resultNode)
 
                if self.__com and testCaseNode.get("requestProgress") == "1":
                    self.setTestCaseListener(None)
 
            elif command == "SetPackageList":
                self.__setPackageList(requestNode.find("Packages"), resultNode)
            elif command == "BuildTestAgenda":
                self.__buildTestAgenda(requestNode.find("Configuration"), resultNode)
            elif command == "BuildTestCaseAgenda":
                self.__buildTestCaseAgenda(requestNode, resultNode)
            else:
                raise Exception("Unknown command: %s" % (command))
        except:
            resultNode.set("errorCode", "Exception")
            etree.SubElement(resultNode, "Error").text = traceback.format_exc()
            mevis.MLAB.log(traceback.format_exc())
            self.__running = False
 
        content = etree.tostring(resultNode).decode()
        mevis.MLAB.log("Result content: %s%s" % (content[:150], " [...]" if len(content) > 150 else ""))
        return resultNode
 
    # --------------------------------------------------------------------------------------------}}}-
 
    # -- def run ---------------------------------------------------------------------------------{{{-
    
    def run(self):
        self.__com.connect()
        self.__running = True
        TestHelper.getInstance().runTestInSecureMode()
        while self.__running:
            request = self.__com.recv(20)
            if request in ("", None):
                mevis.MLAB.logError(self.__com.getLastErrorWithMessage()[1])
                break
 
            requestNode = etree.fromstring(request)
            resultNode = self.runCommand(requestNode)
 
            if not self.__com.send(etree.tostring(resultNode), 5):
                mevis.MLAB.logError("Couldn't send result to request %s" % (request))
                self.__running = False
        TestHelper.getInstance().runTestInCurrentMlabInstance()
        self.__com.disconnect()
 
    # --------------------------------------------------------------------------------------------}}}-
 
 
# ----------------------------------------------------------------------------------------------}}}-