eric: comparison eric7/Unittest/UnittestWidget.py

-:339bb8c8007d
+:39405e6eba20
 """
 Module implementing a widget to orchestrate unit test execution.
 """
+import contextlib
 import enum
 import locale
 import os
-from PyQt6.QtCore import pyqtSlot, Qt, QEvent, QCoreApplication
+from PyQt6.QtCore import pyqtSignal, pyqtSlot, Qt, QEvent, QCoreApplication
 from PyQt6.QtWidgets import (
 QAbstractButton, QComboBox, QDialogButtonBox, QWidget
 )
 from EricWidgets import EricMessageBox
 # TODO: add a "Show Coverage" function using PyCoverageDialog
 class UnittestWidget(QWidget, Ui_UnittestWidget):
 """
 Class implementing a widget to orchestrate unit test execution.
+@signal unittestFile(str, int, bool) emitted to show the source of a
+unittest file
+@signal unittestStopped() emitted after a unit test was run
 """
+unittestFile = pyqtSignal(str, int, bool)
+unittestStopped = pyqtSignal()
 def __init__(self, testfile=None, parent=None):
 """
 Constructor
 @param testfile file name of the test to load
 self.__resultsModel = TestResultsModel(self)
 self.__resultsModel.summary.connect(self.__setStatusLabel)
 self.__resultsTree = TestResultsTreeView(self)
 self.__resultsTree.setModel(self.__resultsModel)
+self.__resultsTree.goto.connect(self.__showSource)
 self.resultsGroupBox.layout().addWidget(self.__resultsTree)
 self.versionsButton.setIcon(
 UI.PixmapCache.getIcon("info"))
 self.clearHistoriesButton.setIcon(
 Qt.WindowType.WindowContextHelpButtonHint
 )
 self.setWindowIcon(UI.PixmapCache.getIcon("eric"))
 self.setWindowTitle(self.tr("Unittest"))
-from VirtualEnv.VirtualenvManager import VirtualenvManager
+try:
-self.__venvManager = VirtualenvManager(self)
+# we are called from within the eric IDE
-self.__venvManager.virtualEnvironmentAdded.connect(
+self.__venvManager = ericApp().getObject("VirtualEnvManager")
-self.__populateVenvComboBox)
+self.__project = ericApp().getObject("Project")
-self.__venvManager.virtualEnvironmentRemoved.connect(
+self.__project.projectOpened.connect(self.__projectOpened)
-self.__populateVenvComboBox)
+self.__project.projectClosed.connect(self.__projectClosed)
-self.__venvManager.virtualEnvironmentChanged.connect(
+except KeyError:
-self.__populateVenvComboBox)
+# we were called as a standalone application
+from VirtualEnv.VirtualenvManager import VirtualenvManager
-# TODO: implement project mode
+self.__venvManager = VirtualenvManager(self)
-self.__forProject = False
+self.__venvManager.virtualEnvironmentAdded.connect(
+self.__populateVenvComboBox)
+self.__venvManager.virtualEnvironmentRemoved.connect(
+self.__populateVenvComboBox)
+self.__venvManager.virtualEnvironmentChanged.connect(
+self.__populateVenvComboBox)
+self.__project = None
 self.__discoverHistory = []
 self.__fileHistory = []
 self.__testNameHistory = []
 self.__recentFramework = ""
 self.__editors = []
 self.__testExecutor = None
 # connect some signals
 self.frameworkComboBox.currentIndexChanged.connect(
-self.__resetResults)
-self.discoverCheckBox.toggled.connect(
 self.__resetResults)
 self.discoveryPicker.editTextChanged.connect(
 self.__resetResults)
 self.testsuitePicker.editTextChanged.connect(
 self.__resetResults)
 self.__setIdleMode()
 self.__loadRecent()
 self.__populateVenvComboBox()
-if self.__forProject:
+if self.__project and self.__project.isOpen():
-project = ericApp().getObject("Project")
+self.venvComboBox.setCurrentText(self.__project.getProjectVenv())
-if project.isOpen():
+self.frameworkComboBox.setCurrentText(
-self.__insertDiscovery(project.getProjectPath())
+self.__project.getProjectTestingFramework())
-else:
+self.__insertDiscovery(self.__project.getProjectPath())
-self.__insertDiscovery("")
 else:
 self.__insertDiscovery("")
 self.__insertTestFile(testfile)
 self.__insertTestName("")
 self.clearHistoriesButton.clicked.connect(self.clearRecent)
 self.venvComboBox.clear()
 self.venvComboBox.addItem("")
 self.venvComboBox.addItems(
 sorted(self.__venvManager.getVirtualenvNames()))
-index = self.venvComboBox.findText(currentText)
+self.venvComboBox.setCurrentText(currentText)
-if index < 0:
-index = 0
-self.venvComboBox.setCurrentIndex(index)
 def __populateTestFrameworkComboBox(self):
 """
 Private method to (re-)populate the test framework selector.
 """
 @return reference to the test results model
 @rtype TestResultsModel
 """
 return self.__resultsModel
+def hasFailedTests(self):
+"""
+Public method to check for failed tests.
+@return flag indicating the existence of failed tests
+@rtype bool
+"""
+return bool(self.__resultsModel.getFailedTests())
 def getFailedTests(self):
 """
 Public method to get the list of failed tests (if any).
 @return list of IDs of failed tests
 @param history array containing the history
 @type list of str
 @param item item to be inserted
 @type str
 """
-current = widget.currentText()
 # prepend the given directory to the discovery picker
 if item is None:
 item = ""
 if item in history:
 history.remove(item)
 history.insert(0, item)
 widget.clear()
 widget.addItems(history)
+widget.setEditText(item)
-if current:
-widget.setEditText(current)
 @pyqtSlot(str)
 def __insertDiscovery(self, start):
 """
 Private slot to insert the discovery start directory into the
 @param start start directory name to be inserted
 @type str
 """
 self.__insertHistory(self.discoveryPicker, self.__discoverHistory,
 start)
+@pyqtSlot(str)
+def setTestFile(self, testFile):
+"""
+Public slot to set the given test file as the current one.
+@param testFile path of the test file
+@type str
+"""
+if testFile:
+self.__insertTestFile(testFile)
+self.discoverCheckBox.setChecked(not bool(testFile))
+self.tabWidget.setCurrentIndex(0)
 @pyqtSlot(str)
 def __insertTestFile(self, prog):
 """
 Private slot to insert a test file name into the testsuitePicker
 self.progressGroupBox.hide()
 self.__updateButtonBoxButtons()
+self.unittestStopped.emit()
 self.raise_()
 self.activateWindow()
+@pyqtSlot(bool)
+def on_discoverCheckBox_toggled(self, checked):
+"""
+Private slot handling state changes of the 'discover' checkbox.
+@param checked state of the checkbox
+@type bool
+"""
+if not bool(self.discoveryPicker.currentText()):
+if self.__project and self.__project.isOpen():
+self.__insertDiscovery(self.__project.getProjectPath())
+else:
+self.__insertDiscovery(
+Preferences.getMultiProject("Workspace"))
+self.__resetResults()
 @pyqtSlot()
 def on_testsuitePicker_aboutToShowPathPickerDialog(self):
 """
 Private slot called before the test file selection dialog is shown.
 """
-# TODO: implement eric-ide mode
+if self.__project:
-#        if self.__dbs:
+# we were called from within eric
-#            py3Extensions = ' '.join(
+py3Extensions = ' '.join([
-#                ["*{0}".format(ext)
+"*{0}".format(ext)
-#                 for ext in self.__dbs.getExtensions('Python3')]
+for ext in
-#            )
+ericApp().getObject("DebugServer").getExtensions('Python3')
-#            fileFilter = self.tr(
+])
-#                "Python3 Files ({0});;All Files (*)"
+fileFilter = self.tr(
-#            ).format(py3Extensions)
+"Python3 Files ({0});;All Files (*)"
-#        else:
+).format(py3Extensions)
-fileFilter = self.tr("Python Files (*.py);;All Files (*)")
+else:
+# standalone application
+fileFilter = self.tr("Python Files (*.py);;All Files (*)")
 self.testsuitePicker.setFilters(fileFilter)
-defaultDirectory = Preferences.getMultiProject("Workspace")
+defaultDirectory = (
+self.__project.getProjectPath()
+if self.__project and self.__project.isOpen() else
+Preferences.getMultiProject("Workspace")
+)
 if not defaultDirectory:
 defaultDirectory = os.path.expanduser("~")
-#        if self.__dbs:
-#            project = ericApp().getObject("Project")
-#            if self.__forProject and project.isOpen():
-#                defaultDirectory = project.getProjectPath()
 self.testsuitePicker.setDefaultDirectory(defaultDirectory)
 @pyqtSlot(QAbstractButton)
 def on_buttonBox_clicked(self, button):
 """
 @param statusText text to be shown
 @type str
 """
 self.statusLabel.setText(f"<b>{statusText}</b>")
+@pyqtSlot()
+def __projectOpened(self):
+"""
+Private slot to handle a project being opened.
+"""
+self.venvComboBox.setCurrentText(self.__project.getProjectVenv())
+self.frameworkComboBox.setCurrentText(
+self.__project.getProjectTestingFramework())
+self.__insertDiscovery(self.__project.getProjectPath())
+@pyqtSlot()
+def __projectClosed(self):
+"""
+Private slot to handle a project being closed.
+"""
+self.venvComboBox.setCurrentText("")
+self.frameworkComboBox.setCurrentText("")
+self.__insertDiscovery("")
+@pyqtSlot(str, int)
+def __showSource(self, filename, lineno):
+"""
+Private slot to show the source of a traceback in an editor.
+@param filename file name of the file to be shown
+@type str
+@param lineno line number to go to in the file
+@type int
+"""
+if self.__project:
+# running as part of eric IDE
+self.unittestFile.emit(filename, lineno, True)
+else:
+self.__openEditor(filename, lineno)
+def __openEditor(self, filename, linenumber):
+"""
+Private method to open an editor window for the given file.
+Note: This method opens an editor window when the unittest dialog
+is called as a standalone application.
+@param filename path of the file to be opened
+@type str
+@param linenumber line number to place the cursor at
+@type int
+"""
+from QScintilla.MiniEditor import MiniEditor
+editor = MiniEditor(filename, "Python3", self)
+editor.gotoLine(linenumber)
+editor.show()
+self.__editors.append(editor)
+def closeEvent(self, event):
+"""
+Protected method to handle the close event.
+@param event close event
+@type QCloseEvent
+"""
+event.accept()
+for editor in self.__editors:
+with contextlib.suppress(Exception):
+editor.close()
 class UnittestWindow(EricMainWindow):
 """
 Main window class for the standalone dialog.

Mercurial Repositories > eric / file comparison

comparison: eric7/Unittest/UnittestWidget.py

eric7/Unittest/UnittestWidget.py