eric: comparison eric7/Unittest/UnittestWidget.py

-:22dab1be7953
+:7f27bf3b50c3
 """
 Module implementing a widget to orchestrate unit test execution.
 """
 import enum
+import locale
 import os
 from PyQt6.QtCore import pyqtSlot, Qt, QEvent, QCoreApplication
 from PyQt6.QtWidgets import (
 QAbstractButton, QComboBox, QDialogButtonBox, QWidget
 from .Ui_UnittestWidget import Ui_UnittestWidget
 from .UTTestResultsTree import TestResultsModel, TestResultsTreeView
 from .Interfaces import Frameworks
-from .Interfaces.UTExecutorBase import UTTestConfig, UTTestResult
+from .Interfaces.UTExecutorBase import (
+UTTestConfig, UTTestResult, ResultCategory
+)
 from .Interfaces.UTFrameworkRegistry import UTFrameworkRegistry
 import Preferences
 import UI.PixmapCache
 """
 IDLE = 0            # idle, no test were run yet
 RUNNING = 1         # test run being performed
 STOPPED = 2         # test run finished
+# TODO: add a "Show Coverage" function using PyCoverageDialog
 class UnittestWidget(QWidget, Ui_UnittestWidget):
 """
 Class implementing a widget to orchestrate unit test execution.
 """
 self.__insertDiscovery(project.getProjectPath())
 else:
 self.__insertDiscovery("")
 else:
 self.__insertDiscovery("")
-self.__insertProg(testfile)
+self.__insertTestFile(testfile)
 self.__insertTestName("")
 self.clearHistoriesButton.clicked.connect(self.clearRecent)
 self.tabWidget.setCurrentIndex(0)
 history.insert(0, item)
 widget.clear()
 widget.addItems(history)
 if current:
-widget.setText(current)
+widget.setEditText(current)
 @pyqtSlot(str)
 def __insertDiscovery(self, start):
 """
 Private slot to insert the discovery start directory into the
 """
 self.__insertHistory(self.discoveryPicker, self.__discoverHistory,
 start)
 @pyqtSlot(str)
-def __insertProg(self, prog):
+def __insertTestFile(self, prog):
 """
 Private slot to insert a test file name into the testsuitePicker
 object.
 @param prog test file name to be inserted
 else:
 self.__startButton.setEnabled(False)
 self.__startButton.setDefault(False)
 # Start Failed button
-# TODO: not implemented yet
+# TODO: not implemented yet (Start Failed button)
 # Stop button
 self.__stopButton.setEnabled(
 self.__mode == UnittestWidgetModes.RUNNING)
 self.__stopButton.setDefault(
 self.__mode == UnittestWidgetModes.RUNNING)
+# Close button
+self.buttonBox.button(
+QDialogButtonBox.StandardButton.Close
+).setEnabled(self.__mode in (
+UnittestWidgetModes.IDLE, UnittestWidgetModes.STOPPED
+))
+def __updateProgress(self):
+"""
+Private method update the progress indicators.
+"""
+self.progressCounterRunCount.setText(
+str(self.__runCount))
+self.progressCounterRemCount.setText(
+str(self.__totalCount - self.__runCount))
+self.progressProgressBar.setMaximum(self.__totalCount)
+self.progressProgressBar.setValue(self.__runCount)
 def __setIdleMode(self):
 """
 Private method to switch the widget to idle mode.
 """
 self.__mode = UnittestWidgetModes.IDLE
 self.__updateButtonBoxButtons()
+self.tabWidget.setCurrentIndex(0)
 def __setRunningMode(self):
 """
 Private method to switch the widget to running mode.
 """
-# TODO: not implemented yet
+self.__mode = UnittestWidgetModes.RUNNING
-pass
+self.__totalCount = 0
+self.__runCount = 0
+self.__coverageFile = ""
+# TODO: implement the handling of the 'Show Coverage' button
+self.sbLabel.setText(self.tr("Running"))
+self.tabWidget.setCurrentIndex(1)
+self.__updateButtonBoxButtons()
+self.__updateProgress()
+self.__resultsModel.clear()
 def __setStoppedMode(self):
 """
 Private method to switch the widget to stopped mode.
 """
-# TODO: not implemented yet
+self.__mode = UnittestWidgetModes.STOPPED
-pass
+self.__updateButtonBoxButtons()
+self.raise_()
+self.activateWindow()
 @pyqtSlot(QAbstractButton)
 def on_buttonBox_clicked(self, button):
 """
 Private slot called by a button of the button box clicked.
 @param button button that was clicked
 @type QAbstractButton
 """
-##        if button == self.discoverButton:
-##            self.__discover()
-##            self.__saveRecent()
-##        elif button == self.__startButton:
 if button == self.__startButton:
 self.startTests()
 self.__saveRecent()
 elif button == self.__stopButton:
 self.__stopTests()
 self.__insertDiscovery(discoveryStart)
 else:
 discoveryStart = ""
 testFileName = self.testsuitePicker.currentText()
 if testFileName:
-self.__insertProg(testFileName)
+self.__insertTestFile(testFileName)
 testName = self.testComboBox.currentText()
 if testName:
-self.insertTestName(testName)
+self.__insertTestName(testName)
 if testFileName and not testName:
 testName = "suite"
+self.sbLabel.setText(self.tr("Preparing Testsuite"))
+QCoreApplication.processEvents()
 interpreter = self.__venvManager.getVirtualenvInterpreter(
 self.__recentEnvironment)
 config = UTTestConfig(
 interpreter=interpreter,
 )
 self.__resultsModel.clear()
 self.__testExecutor = self.__frameworkRegistry.createExecutor(
 self.__recentFramework, self)
-self.__testExecutor.collected.connect(self.__testCollected)
+self.__testExecutor.collected.connect(self.__testsCollected)
 self.__testExecutor.collectError.connect(self.__testsCollectError)
-self.__testExecutor.startTest.connect(self.__testsStarted)
+self.__testExecutor.startTest.connect(self.__testStarted)
 self.__testExecutor.testResult.connect(self.__processTestResult)
 self.__testExecutor.testFinished.connect(self.__testProcessFinished)
+self.__testExecutor.testRunFinished.connect(self.__testRunFinished)
 self.__testExecutor.stop.connect(self.__testsStopped)
+self.__testExecutor.coverageDataSaved.connect(self.__coverageData)
+self.__setRunningMode()
 self.__testExecutor.start(config, [])
-# TODO: not yet implemented
+@pyqtSlot()
-pass
+def __stopTests(self):
+"""
+Private slot to stop the current test run.
+"""
+self.__testExecutor.stopIfRunning()
 @pyqtSlot(list)
-def __testCollected(self, testNames):
+def __testsCollected(self, testNames):
 """
 Private slot handling the 'collected' signal of the executor.
-@param testNames list of names of collected tests
+@param testNames list of tuples containing the test id and test name
-@type list of str
+of collected tests
-"""
+@type list of tuple of (str, str)
-# TODO: not implemented yet
+"""
-pass
+testResults = [
+UTTestResult(
+category=ResultCategory.PENDING,
+status=self.tr("pending"),
+name=name,
+id=id,
+message=desc,
+) for id, name, desc in testNames
+]
+self.__resultsModel.setTestResults(testResults)
+self.__totalCount = len(testResults)
+self.__updateProgress()
 @pyqtSlot(list)
 def __testsCollectError(self, errors):
 """
 Private slot handling the 'collectError' signal of the executor.
 @param errors list of tuples containing the test name and a description
 of the error
 @type list of tuple of (str, str)
 """
-# TODO: not implemented yet
+testResults = []
-pass
+for testFile, error in errors:
-@pyqtSlot(list)
+if testFile:
-def __testsStarted(self, testNames):
+testResults.append(UTTestResult(
+category=ResultCategory.FAIL,
+status=self.tr("Failure"),
+name=testFile,
+id=testFile,
+message=self.tr("Collection Error"),
+extra=error.splitlines()
+))
+else:
+EricMessageBox.critical(
+self,
+self.tr("Collection Error"),
+self.tr(
+"<p>There was an error while collecting unit tests."
+"</p><p>{0}</p>"
+).format("<br/>".join(error.splitlines()))
+)
+if testResults:
+self.__resultsModel.addTestResults(testResults)
+@pyqtSlot(tuple)
+def __testStarted(self, test):
 """
 Private slot handling the 'startTest' signal of the executor.
-@param testNames list of names of tests about to be run
+@param test tuple containing the id, name and short description of the
-@type list of str
+tests about to be run
-"""
+@type tuple of (str, str, str)
-# TODO: not implemented yet
+"""
-pass
+self.__resultsModel.updateTestResults([
+UTTestResult(
+category=ResultCategory.RUNNING,
+status=self.tr("running"),
+id=test[0],
+name=test[1],
+message="" if test[2] is None else test[2],
+)
+])
 @pyqtSlot(UTTestResult)
 def __processTestResult(self, result):
 """
 Private slot to handle the receipt of a test result object.
 @param result test result object
 @type UTTestResult
 """
-# TODO: not implemented yet
+self.__runCount += 1
-pass
+self.__updateProgress()
+self.__resultsModel.updateTestResults([result])
 @pyqtSlot(list, str)
 def __testProcessFinished(self, results, output):
 """
 Private slot to handle the 'testFinished' signal of the executor.
 'testResult' signal
 @type list of UTTestResult
 @param output string containing the test process output (if any)
 @type str
 """
-# TODO: not implemented yet
+self.__setStoppedMode()
-pass
+self.__testExecutor = None
+@pyqtSlot(int, float)
+def __testRunFinished(self, noTests, duration):
+"""
+Private slot to handle the 'testRunFinished' signal of the executor.
+@param noTests number of tests run by the executor
+@type int
+@param duration time needed in seconds to run the tests
+@type float
+"""
+self.sbLabel.setText(
+self.tr("Ran %n test(s) in {0}s", "", noTests).format(
+locale.format_string("%.3f", duration, grouping=True)
+)
+)
+self.__setStoppedMode()
 @pyqtSlot()
 def __testsStopped(self):
 """
 Private slot to handle the 'stop' signal of the executor.
 """
-# TODO: not implemented yet
+self.sbLabel.setText(self.tr("Ran %n test(s)", "", self.__runCount))
-pass
+self.__setStoppedMode()
+@pyqtSlot(str)
+def __coverageData(self, coverageFile):
+"""
+Private slot to handle the 'coverageData' signal of the executor.
+@param coverageFile file containing the coverage data
+@type str
+"""
+self.__coverageFile = coverageFile
+# TODO: implement the handling of the 'Show Coverage' button
 class UnittestWindow(EricMainWindow):
 """
 Main window class for the standalone dialog.

Mercurial Repositories > eric / file comparison

comparison: eric7/Unittest/UnittestWidget.py

eric7/Unittest/UnittestWidget.py