eric: comparison PyUnit/UnittestDialog.py

-:94f27ede4186
+:b4d0457afb15
 class UnittestDialog(QWidget, Ui_UnittestDialog):
 """
 Class implementing the UI to the pyunit package.
 @signal unittestFile(str, int, int) emitted to show the source of a unittest file
+@signal unittestStopped() emitted after a unit test was run
 """
 unittestFile = pyqtSignal(str, int, int)
+unittestStopped = pyqtSignal()
 def __init__(self, prog=None, dbs=None, ui=None, fromEric=False, parent=None,
 name=None):
 """
 Constructor
 self.trUtf8("Start"), QDialogButtonBox.ActionRole)
 self.startButton.setToolTip(self.trUtf8("Start the selected testsuite"))
 self.startButton.setWhatsThis(self.trUtf8(
 """<b>Start Test</b>"""
 """<p>This button starts the selected testsuite.</p>"""))
+self.startFailedButton = self.buttonBox.addButton(
+self.trUtf8("Rerun Failed"), QDialogButtonBox.ActionRole)
+self.startFailedButton.setToolTip(
+self.trUtf8("Reruns failed tests of the selected testsuite"))
+self.startFailedButton.setWhatsThis(self.trUtf8(
+"""<b>Rerun Failed</b>"""
+"""<p>This button reruns all failed tests of the selected testsuite.</p>"""))
 self.stopButton = self.buttonBox.addButton(
 self.trUtf8("Stop"), QDialogButtonBox.ActionRole)
 self.stopButton.setToolTip(self.trUtf8("Stop the running unittest"))
 self.stopButton.setWhatsThis(self.trUtf8(
 """<b>Stop Test</b>"""
 """<p>This button stops a running unittest.</p>"""))
 self.stopButton.setEnabled(False)
 self.startButton.setDefault(True)
+self.startFailedButton.setEnabled(False)
 self.dbs = dbs
 self.__fromEric = fromEric
 self.setWindowFlags(
 self.rxPatterns = [
 self.trUtf8("^Failure: "),
 self.trUtf8("^Error: "),
 ]
+self.__failedTests = []
 # now connect the debug server signals if called from the eric5 IDE
 if self.dbs:
 self.dbs.utPrepared.connect(self.__UTPrepared)
 self.dbs.utFinished.connect(self.__setStoppedMode)
 @param txt name of the test file (string)
 """
 if self.dbs:
 exts = self.dbs.getExtensions("Python2")
-if txt.endswith(exts):
+flags = Utilities.extractFlagsFromFile(txt)
+if txt.endswith(exts) or \
+("FileType" in flags and
+flags["FileType"] in ["Python", "Python2"]):
 self.coverageCheckBox.setChecked(False)
 self.coverageCheckBox.setEnabled(False)
 self.localCheckBox.setChecked(False)
 self.localCheckBox.setEnabled(False)
 return
 """
 if button == self.startButton:
 self.on_startButton_clicked()
 elif button == self.stopButton:
 self.on_stopButton_clicked()
+elif button == self.startFailedButton:
+self.on_startButton_clicked(failedOnly=True)
 @pyqtSlot()
-def on_startButton_clicked(self):
+def on_startButton_clicked(self, failedOnly=False):
 """
 Public slot to start the test.
+@keyparam failedOnly flag indicating to run only failed tests (boolean)
 """
 if self.running:
 return
 prog = self.testsuiteComboBox.currentText()
 ("FileType" in flags and
 flags["FileType"] in ["Python", "Python2"]):
 clientType = "Python2"
 else:
 clientType = ""
+if failedOnly and self.__failedTests:
+failed = [t.split(".", 1)[1] for t in self.__failedTests]
+else:
+failed = []
+self.__failedTests = []
 self.dbs.remoteUTPrepare(prog, self.testName, testFunctionName,
+failed,
 self.coverageCheckBox.isChecked(), mainScript,
 self.coverageEraseCheckBox.isChecked(), clientType=clientType)
 else:
 # we are running as an application or in local mode
 sys.path = [os.path.dirname(os.path.abspath(prog))] + self.savedSysPath
 # now try to generate the testsuite
 try:
 module = __import__(self.testName)
 try:
-test = unittest.defaultTestLoader.loadTestsFromName(
+if failedOnly and self.__failedTests:
-testFunctionName, module)
+test = unittest.defaultTestLoader.loadTestsFromNames(
+[t.split(".", 1)[1] for t in self.__failedTests],
+module)
+else:
+test = unittest.defaultTestLoader.loadTestsFromName(
+testFunctionName, module)
 except AttributeError:
 test = unittest.defaultTestLoader.loadTestsFromModule(module)
 except:
 exc_type, exc_value, exc_tb = sys.exc_info()
 E5MessageBox.critical(self,
 else:
 cover = None
 self.testResult = QtTestResult(self)
 self.totalTests = test.countTestCases()
+self.__failedTests = []
 self.__setRunningMode()
 if cover:
 cover.start()
 test.run(self.testResult)
 if cover:
 self.stopTime = time.time()
 self.timeTaken = float(self.stopTime - self.startTime)
 self.running = False
 self.startButton.setEnabled(True)
+self.startFailedButton.setEnabled(bool(self.__failedTests))
 self.stopButton.setEnabled(False)
-self.startButton.setDefault(True)
+if self.__failedTests:
+self.startFailedButton.setDefault(True)
+self.startButton.setDefault(False)
+else:
+self.startFailedButton.setDefault(False)
+self.startButton.setDefault(True)
 if self.runCount == 1:
 self.sbLabel.setText(self.trUtf8("Ran {0} test in {1:.3f}s")
 .format(self.runCount, self.timeTaken))
 else:
 self.sbLabel.setText(self.trUtf8("Ran {0} tests in {1:.3f}s")
 .format(self.runCount, self.timeTaken))
 self.progressLed.off()
-def testFailed(self, test, exc):
+self.unittestStopped.emit()
+def testFailed(self, test, exc, id):
 """
 Public method called if a test fails.
-@param test name of the failed test (string)
+@param test name of the test (string)
 @param exc string representation of the exception (string)
+@param id id of the test (string)
 """
 self.failCount += 1
 self.progressCounterFailureCount.setText(str(self.failCount))
 itm = QListWidgetItem(self.trUtf8("Failure: {0}").format(test))
 itm.setData(Qt.UserRole, (test, exc))
 self.errorsListWidget.insertItem(0, itm)
+self.__failedTests.append(id)
-def testErrored(self, test, exc):
+def testErrored(self, test, exc, id):
 """
 Public method called if a test errors.
-@param test name of the failed test (string)
+@param test name of the test (string)
 @param exc string representation of the exception (string)
+@param id id of the test (string)
 """
 self.errorCount += 1
 self.progressCounterErrorCount.setText(str(self.errorCount))
 itm = QListWidgetItem(self.trUtf8("Error: {0}").format(test))
 itm.setData(Qt.UserRole, (test, exc))
 self.errorsListWidget.insertItem(0, itm)
+self.__failedTests.append(id)
-def testSkipped(self, test, reason):
+def testSkipped(self, test, reason, id):
 """
 Public method called if a test was skipped.
-@param test name of the failed test (string)
+@param test name of the test (string)
 @param reason reason for skipping the test (string)
+@param id id of the test (string)
 """
 self.skippedCount += 1
 self.progressCounterSkippedCount.setText(str(self.skippedCount))
 itm = QListWidgetItem(self.trUtf8("    Skipped: {0}").format(reason))
 itm.setForeground(Qt.blue)
 self.testsListWidget.insertItem(1, itm)
-def testFailedExpected(self, test, exc):
+def testFailedExpected(self, test, exc, id):
 """
-Public method called if a test fails expected.
+Public method called if a test fails expectedly.
-@param test name of the failed test (string)
+@param test name of the test (string)
 @param exc string representation of the exception (string)
+@param id id of the test (string)
 """
 self.expectedFailureCount += 1
 self.progressCounterExpectedFailureCount.setText(str(self.expectedFailureCount))
 itm = QListWidgetItem(self.trUtf8("    Expected Failure"))
 itm.setForeground(Qt.blue)
 self.testsListWidget.insertItem(1, itm)
-def testSucceededUnexpected(self, test):
+def testSucceededUnexpected(self, test, id):
 """
 Public method called if a test succeeds unexpectedly.
-@param test name of the failed test (string)
+@param test name of the test (string)
+@param id id of the test (string)
 """
 self.unexpectedSuccessCount += 1
 self.progressCounterUnexpectedSuccessCount.setText(
 str(self.unexpectedSuccessCount))
 itm = QListWidgetItem(self.trUtf8("    Unexpected Success"))
 if fmatch:
 break
 if fmatch:
 fn, ln = fmatch.group(1, 2)
 self.unittestFile.emit(fn, int(ln), 1)
+def hasFailedTests(self):
+"""
+Public method to check, if there are failed tests from the last run.
+@return flag indicating the presence of failed tests (boolean)
+"""
+return bool(self.__failedTests)
 class QtTestResult(unittest.TestResult):
 """
 A TestResult derivative to work with a graphical GUI.
 @param test reference to the test object
 @param err error traceback
 """
 super().addFailure(test, err)
 tracebackLines = self._exc_info_to_string(err, test)
-self.parent.testFailed(str(test), tracebackLines)
+self.parent.testFailed(str(test), tracebackLines, test.id())
 def addError(self, test, err):
 """
 Method called if a test errored.
 @param test reference to the test object
 @param err error traceback
 """
 super().addError(test, err)
 tracebackLines = self._exc_info_to_string(err, test)
-self.parent.testErrored(str(test), tracebackLines)
+self.parent.testErrored(str(test), tracebackLines, test.id())
 def addSkip(self, test, reason):
 """
 Method called if a test was skipped.
 @param test reference to the test object
 @param reason reason for skipping the test (string)
 """
 super().addSkip(test, reason)
-self.parent.testSkipped(str(test), reason)
+self.parent.testSkipped(str(test), reason, test.id())
 def addExpectedFailure(self, test, err):
 """
 Method called if a test failed expected.
 @param test reference to the test object
 @param err error traceback
 """
 super().addExpectedFailure(test, err)
 tracebackLines = self._exc_info_to_string(err, test)
-self.parent.testFailedExpected(str(test), tracebackLines)
+self.parent.testFailedExpected(str(test), tracebackLines, test.id())
 def addUnexpectedSuccess(self, test):
 """
 Method called if a test succeeded expectedly.
 @param test reference to the test object
 """
 super().addUnexpectedSuccess(test)
-self.parent.testSucceededUnexpected(str(test))
+self.parent.testSucceededUnexpected(str(test), test.id())
 def startTest(self, test):
 """
 Method called at the start of a test.

Mercurial Repositories > eric / file comparison

comparison: PyUnit/UnittestDialog.py

PyUnit/UnittestDialog.py