Add support for qt_log_ignore ini option

Author: nicoddemus

pytestqt/_tests/test_logging.py

@@ -174,3 +174,61 @@ def test_1():
     )
     res = testdir.inline_run()
     res.assertoutcome(failed=1)
+
+
+def test_logging_fails_ignore(testdir):
+    """
+    Test qt_log_ignore config option.
+
+    :type testdir: _pytest.pytester.TmpTestdir
+    """
+    testdir.makeini(
+        """
+        [pytest]
+        qt_log_level_fail = CRITICAL
+        qt_log_ignore = WM_DESTROY.*sent
+        """
+    )
+    testdir.makepyfile(
+        """
+        from pytestqt.qt_compat import qWarning, qCritical
+        import pytest
+
+        def test1():
+            qCritical('a critical message')
+        def test2():
+            qCritical('WM_DESTROY was sent')
+        def test3():
+            qCritical('WM_DESTROY was sent')
+            assert 0
+        def test4():
+            qCritical('WM_DESTROY was sent')
+            qCritical('another critical message')
+        """
+    )
+    res = testdir.runpytest()
+    lines = [
+        # test1 fails because it has emitted a CRITICAL message and that message
+        # does not match any regex in qt_log_ignore
+        '*_ test1 _*',
+        '*Failure: Qt messages with level CRITICAL or above emitted*',
+        '*QtCriticalMsg: a critical message*',
+
+        # test2 succeeds because its message matches qt_log_ignore
+
+        # test3 fails because of an assert, but the ignored message should
+        # still appear in the failure message
+        '*_ test3 _*',
+        '*AssertionError*',
+        '*QtCriticalMsg: WM_DESTROY was sent*(IGNORED)*',
+
+        # test4 fails because one message is ignored but the other isn't
+        '*_ test4 _*',
+        '*Failure: Qt messages with level CRITICAL or above emitted*',
+        '*QtCriticalMsg: WM_DESTROY was sent*(IGNORED)*',
+        '*QtCriticalMsg: another critical message*',
+
+        # summary
+        '*3 failed, 1 passed*',
+    ]
+    res.stdout.fnmatch_lines(lines)

pytestqt/plugin.py

@@ -9,6 +9,7 @@
 from py._code.code import ReprFileLocation
 
 import pytest
+import re
 
 from pytestqt.qt_compat import QtCore, QtTest, QApplication, QT_API, \
     qInstallMsgHandler, QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg
@@ -561,6 +562,9 @@ def pytest_addoption(parser):
                   'log level in which tests can fail: {0} (default: "{1}")'
                   .format(QtLoggingPlugin.LOG_FAIL_OPTIONS, default_log_fail),
                   default=default_log_fail)
+    parser.addini('qt_log_ignore',
+                  'list of regexes for messages that should not cause a tests '
+                  'to fails', type='linelist')
 
     parser.addoption('--no-qt-log', dest='qt_log', action='store_false',
                      default=True)
@@ -604,7 +608,7 @@ def qtlog(request):
     if hasattr(request._pyfuncitem, 'qt_log_capture'):
         return request._pyfuncitem.qt_log_capture
     else:
-        return _QtMessageCapture()  # pragma: no cover
+        return _QtMessageCapture([])  # pragma: no cover
 
 
 class QtLoggingPlugin(object):
@@ -619,7 +623,8 @@ def __init__(self, config):
         self.config = config
 
     def pytest_runtest_setup(self, item):
-        item.qt_log_capture = _QtMessageCapture()
+        item.qt_log_capture = _QtMessageCapture(
+            item.config.getini('qt_log_ignore'))
         previous_handler = qInstallMsgHandler(item.qt_log_capture._handle)
         item.qt_previous_handler = previous_handler
 
@@ -630,8 +635,6 @@ def pytest_runtest_makereport(self, item, call):
         outcome = yield
         report = outcome.result
 
-        log_format = self.config.getoption('qt_log_format')
-
         m = item.get_marker('qt_log_level_fail')
         if m:
             log_fail_level = m.args[0]
@@ -641,21 +644,27 @@ def pytest_runtest_makereport(self, item, call):
 
         if call.when == 'call':
 
+            # make test fail if any records were captured which match
+            # log_fail_level
             if log_fail_level != 'NO' and report.outcome != 'failed':
                 for rec in item.qt_log_capture.records:
-                    if rec.matches_level(log_fail_level):
+                    if rec.matches_level(log_fail_level) and not rec.ignored:
                         report.outcome = 'failed'
                         if report.longrepr is None:
                             report.longrepr = \
                                 _QtLogLevelErrorRepr(item, log_fail_level)
                         break
 
+            # if test has failed, add recorded messages to its terminal
+            # representation
             if not report.passed:
                 long_repr = getattr(report, 'longrepr', None)
                 if hasattr(long_repr, 'addsection'):  # pragma: no cover
+                    log_format = self.config.getoption('qt_log_format')
                     lines = []
                     for rec in item.qt_log_capture.records:
-                        lines.append(log_format.format(rec=rec))
+                        suffix = ' (IGNORED)' if rec.ignored else ''
+                        lines.append(log_format.format(rec=rec) + suffix)
                     if lines:
                         long_repr.addsection('Captured Qt messages',
                                              '\n'.join(lines))
@@ -670,11 +679,14 @@ class _QtMessageCapture(object):
     Captures Qt messages when its `handle` method is installed using
     qInstallMsgHandler, and stores them into `messages` attribute.
 
-    :attr messages: list of Record named-tuples.
+    :attr _records: list of Record instances.
+    :attr _ignore_regexes: list of regexes (as strings) that define if a record
+        should be ignored.
     """
 
-    def __init__(self):
+    def __init__(self, ignore_regexes):
         self._records = []
+        self._ignore_regexes = ignore_regexes or []
 
     def _handle(self, msg_type, message):
         """
@@ -683,7 +695,14 @@ def _handle(self, msg_type, message):
         """
         if isinstance(message, bytes):
             message = message.decode('utf-8', 'replace')
-        self._records.append(Record(msg_type, message))
+
+        ignored = False
+        for regex in self._ignore_regexes:
+            if re.search(regex, message) is not None:
+                ignored = True
+                break
+
+        self._records.append(Record(msg_type, message, ignored))
 
     @property
     def records(self):
@@ -704,20 +723,24 @@ class Record(object):
         type name similar to the logging package, for example ``DEBUG``,
         ``WARNING``, etc.
     :attr datetime.datetime when: when the message was sent
+    :attr ignored: If this record matches a regex from the "qt_log_ignore"
+        option.
     """
 
-    def __init__(self, msg_type, message):
+    def __init__(self, msg_type, message, ignored):
         self._type = msg_type
         self._message = message
         self._type_name = self._get_msg_type_name(msg_type)
         self._log_type_name = self._get_log_type_name(msg_type)
         self._when = datetime.datetime.now()
+        self._ignored = ignored
 
     message = property(lambda self: self._message)
     type = property(lambda self: self._type)
     type_name = property(lambda self: self._type_name)
     log_type_name = property(lambda self: self._log_type_name)
     when = property(lambda self: self._when)
+    ignored = property(lambda self: self._ignored)
 
     @classmethod
     def _get_msg_type_name(cls, msg_type):
@@ -751,11 +774,11 @@ def _get_log_type_name(cls, msg_type):
 
     def matches_level(self, level):
         if level == 'DEBUG':
-            return self.log_type_name in set(['DEBUG', 'WARNING', 'CRITICAL'])
+            return self.log_type_name in ('DEBUG', 'WARNING', 'CRITICAL')
         elif level == 'WARNING':
-            return self.log_type_name in set(['WARNING', 'CRITICAL'])
+            return self.log_type_name in ('WARNING', 'CRITICAL')
         elif level == 'CRITICAL':
-            return self.log_type_name in set(['CRITICAL'])
+            return self.log_type_name in ('CRITICAL',)
         else:
             raise ValueError('log_fail_level unknown: {0}'.format(level))