eric: comparison src/eric7/Testing/Interfaces/TestExecutorBase.py

-:e9e7eca7efee
+:bf71ee032bb4
 class TestResultCategory(IntEnum):
 """
 Class defining the supported result categories.
 """
 RUNNING = 0
 FAIL = 1
 OK = 2
 SKIP = 3
 PENDING = 4
 @dataclass
 class TestResult:
 """
 Class containing the test result data.
 """
-category: TestResultCategory    # result category
-status: str                     # test status
+category: TestResultCategory  # result category
-name: str                       # test name
+status: str  # test status
-id: str                         # test id
+name: str  # test name
-description: str = ""           # short description of test
+id: str  # test id
-message: str = ""               # short result message
+description: str = ""  # short description of test
-extra: list = None              # additional information text
+message: str = ""  # short result message
-duration: float = None          # test duration
+extra: list = None  # additional information text
-filename: str = None            # file name of a failed test
+duration: float = None  # test duration
-lineno: int = None              # line number of a failed test
+filename: str = None  # file name of a failed test
-subtestResult: bool = False     # flag indicating the result of a subtest
+lineno: int = None  # line number of a failed test
+subtestResult: bool = False  # flag indicating the result of a subtest
 @dataclass
 class TestConfig:
 """
 Class containing the test run configuration.
 """
-interpreter: str                # path of the Python interpreter
-discover: bool                  # auto discovery flag
+interpreter: str  # path of the Python interpreter
-discoveryStart: str             # start directory for auto discovery
+discover: bool  # auto discovery flag
-testFilename: str               # name of the test script
+discoveryStart: str  # start directory for auto discovery
-testName: str                   # name of the test function
+testFilename: str  # name of the test script
-failFast: bool                  # stop on first fail
+testName: str  # name of the test function
-failedOnly: bool                # run failed tests only
+failFast: bool  # stop on first fail
-collectCoverage: bool           # coverage collection flag
+failedOnly: bool  # run failed tests only
-eraseCoverage: bool             # erase coverage data first
+collectCoverage: bool  # coverage collection flag
-coverageFile: str               # name of the coverage data file
+eraseCoverage: bool  # erase coverage data first
+coverageFile: str  # name of the coverage data file
 class TestExecutorBase(QObject):
 """
 Base class for test framework specific implementations.
 @signal collected(list of tuple of (str, str, str)) emitted after all tests
 have been collected. Tuple elements are the test id, the test name and
 a short description of the test.
 @signal collectError(list of tuple of (str, str)) emitted when errors
 are encountered during test collection. Tuple elements are the
 The elements are the number of tests run and the duration in seconds
 @signal stop() emitted when the test process is being stopped.
 @signal coverageDataSaved(str) emitted after the coverage data was saved.
 The element is the absolute path of the coverage data file.
 """
 collected = pyqtSignal(list)
 collectError = pyqtSignal(list)
 startTest = pyqtSignal(tuple)
 testResult = pyqtSignal(TestResult)
 testFinished = pyqtSignal(list, str)
 testRunAboutToBeStarted = pyqtSignal()
 testRunFinished = pyqtSignal(int, float)
 stop = pyqtSignal()
 coverageDataSaved = pyqtSignal(str)
 module = ""
 name = ""
 runner = ""
 def __init__(self, testWidget):
 """
 Constructor
 @param testWidget reference to the unit test widget
 @type TestingWidget
 """
 super().__init__(testWidget)
 self.__process = None
 @classmethod
 def isInstalled(cls, interpreter):
 """
 Class method to check whether a test framework is installed.
 The test is performed by checking, if a module loader can found.
 @param interpreter interpreter to be used for the test
 @type str
 @return flag indicating the test framework module is installed
 @rtype bool
 """
 proc = QProcess()
 proc.start(interpreter, [cls.runner, "installed"])
 if proc.waitForFinished(3000):
 exitCode = proc.exitCode()
 return exitCode == 0
 return False
 def getVersions(self, interpreter):
 """
 Public method to get the test framework version and version information
 of its installed plugins.
 @param interpreter interpreter to be used for the test
 @type str
 @return dictionary containing the framework name and version and the
 list of available plugins with name and version each
 @rtype dict
 @exception NotImplementedError this method needs to be implemented by
 derived classes
 """
 raise NotImplementedError
 return {}
 def hasCoverage(self, interpreter):
 """
 Public method to get the test framework version and version information
 of its installed plugins.
 @param interpreter interpreter to be used for the test
 @type str
 @return flag indicating the availability of coverage functionality
 @rtype bool
 @exception NotImplementedError this method needs to be implemented by
 derived classes
 """
 raise NotImplementedError
 return False
 def createArguments(self, config):
 """
 Public method to create the arguments needed to start the test process.
 @param config configuration for the test execution
 @type TestConfig
 @return list of process arguments
 @rtype list of str
 @exception NotImplementedError this method needs to be implemented by
 derived classes
 """
 raise NotImplementedError
 return []
 def _prepareProcess(self, workDir, pythonpath):
 """
 Protected method to prepare a process object to be started.
 @param workDir working directory
 @type str
 @param pythonpath list of directories to be added to the Python path
 @type list of str
 @return prepared process object
 @rtype QProcess
 """
 process = QProcess(self)
-process.setProcessChannelMode(
+process.setProcessChannelMode(QProcess.ProcessChannelMode.MergedChannels)
-QProcess.ProcessChannelMode.MergedChannels)
 process.setWorkingDirectory(workDir)
 process.finished.connect(self.finished)
 if pythonpath:
 env = QProcessEnvironment.systemEnvironment()
-currentPythonPath = env.value('PYTHONPATH', None)
+currentPythonPath = env.value("PYTHONPATH", None)
 newPythonPath = os.pathsep.join(pythonpath)
 if currentPythonPath:
 newPythonPath += os.pathsep + currentPythonPath
-env.insert('PYTHONPATH', newPythonPath)
+env.insert("PYTHONPATH", newPythonPath)
 process.setProcessEnvironment(env)
 return process
 def start(self, config, pythonpath):
 """
 Public method to start the testing process.
 @param config configuration for the test execution
 @type TestConfig
 @param pythonpath list of directories to be added to the Python path
 @type list of str
 @exception RuntimeError raised if the the testing process did not start
 """
 workDir = (
 config.discoveryStart
-if config.discover else
+if config.discover
-os.path.dirname(config.testFilename)
+else os.path.dirname(config.testFilename)
 )
 self.__process = self._prepareProcess(workDir, pythonpath)
 testArgs = self.createArguments(config)
 self.testRunAboutToBeStarted.emit()
 self.__process.start(config.interpreter, testArgs)
 running = self.__process.waitForStarted()
 if not running:
 raise RuntimeError
 def finished(self):
 """
 Public method handling the unit test process been finished.
 This method should read the results (if necessary) and emit the signal
 testFinished.
 @exception NotImplementedError this method needs to be implemented by
 derived classes
 """
 raise NotImplementedError
 def readAllOutput(self, process=None):
 """
 Public method to read all output of the test process.
 @param process reference to the process object
 @type QProcess
 @return test process output
 @rtype str
 """
 if process is None:
 process = self.__process
 output = (
-str(process.readAllStandardOutput(),
+str(
+process.readAllStandardOutput(),
 Preferences.getSystem("IOEncoding"),
-'replace').strip()
+"replace",
-if process else
+).strip()
-""
+if process
+else ""
 )
 return output
 def stopIfRunning(self):
 """
 Public method to stop the testing process, if it is running.
 """
-if (
+if self.__process and self.__process.state() == QProcess.ProcessState.Running:
-self.__process and
-self.__process.state() == QProcess.ProcessState.Running
-):
 self.__process.terminate()
 self.__process.waitForFinished(2000)
 self.__process.kill()
 self.__process.waitForFinished(3000)
 self.stop.emit()

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Testing/Interfaces/TestExecutorBase.py

src/eric7/Testing/Interfaces/TestExecutorBase.py