pytest-regtest 2.2.0a2__py2.py3-none-any.whl → 2.2.1__py2.py3-none-any.whl

pytest_regtest/pytest_regtest.py

@@ -6,17 +6,18 @@ import re
 import shutil
 import sys
 import tempfile
+from collections.abc import Callable
 from hashlib import sha512
 from io import StringIO
+from typing import Optional
 
+import _pytest
 import pytest
 from _pytest._code.code import TerminalRepr
 from _pytest._io import TerminalWriter
 
-# from .numpy_handler import NumpyHandler  # noqa: F401
-# from .pandas_handler import DataFrameHandler  # noqa: F401
 from .snapshot_handler import PythonObjectHandler  # noqa: F401
-from .snapshot_handler import snapshot_handlers
+from .snapshot_handler import SnapshotHandlerRegistry
 
 IS_WIN = sys.platform == "win32"
 
@@ -36,90 +37,90 @@ class RegtestException(Exception):
     pass
 
 
-class RecordedOutputException(Exception):
+class RecordedOutputException(RegtestException):
     pass
 
 
-class SnapshotException(Exception):
+class SnapshotException(RegtestException):
     pass
 
 
-class PytestRegtestPlugin:
+class PytestRegtestCommonHooks:
     def __init__(self):
+        self._reset_snapshots = []
         self._reset_regtest_outputs = []
+        self._failed_snapshots = []
         self._failed_regtests = []
 
-    @pytest.hookimpl(trylast=True)
-    def pytest_runtest_call(self, item):
-        if not hasattr(item, "regtest_stream"):
-            return
-
-        output_exception = self.check_recorded_output(item)
-        snapshot_exception = self.check_snapshots(item)
-
-        if output_exception is not None or snapshot_exception is not None:
-            raise RegtestException(output_exception, snapshot_exception)
-
-        if item.get_closest_marker("xfail") and item.config.getvalue("--regtest-reset"):
-            # enforce fail
-            assert False
-
-    def check_snapshots(self, item):
-        results = []
-
-        any_failed = False
-        for idx, snapshot in enumerate(item.regtest_stream.snapshots):
-            is_recorded, ok, msg = self.check_snapshot(idx, item, snapshot)
-            if not ok:
-                any_failed = True
-            results.append((ok, snapshot, is_recorded, msg))
-
-        if any_failed:
-            return SnapshotException(results)
+    @pytest.hookimpl(hookwrapper=False)
+    def pytest_terminal_summary(self, terminalreporter, exitstatus, config):
+        tr = terminalreporter
+        tr.ensure_newline()
+        tr.section("pytest-regtest report", sep="-", blue=True, bold=True)
+        tr.write("total number of failed regression tests: ", bold=True)
+        tr.line(str(len(self._failed_regtests)))
+        tr.write("total number of failed snapshot tests  : ", bold=True)
+        tr.line(str(len(self._failed_snapshots)))
 
-    def check_snapshot(self, idx, item, snapshot):
-        obj, handler_options, _ = snapshot
-        handler = get_snapshot_handler(obj, handler_options, item.config)
+        if config.getvalue("--regtest-reset"):
+            if config.option.verbose:
+                tr.line("the following output files have been reset:", bold=True)
+                for path in self._reset_regtest_outputs:
+                    rel_path = os.path.relpath(path)
+                    tr.line("  " + rel_path)
+                for path in self._reset_snapshots:
+                    rel_path = os.path.relpath(path)
+                    tr.line("  " + rel_path)
+            else:
+                tr.write("total number of reset output files: ", bold=True)
+                tr.line(
+                    str(len(self._reset_regtest_outputs) + len(self._reset_snapshots))
+                )
 
-        test_folder = item.fspath.dirname
-        identifier = str(idx)
-        config = item.config
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_pyfunc_call(self, pyfuncitem):
+        stdout = sys.stdout
+        if "regtest_all" in pyfuncitem.fixturenames and hasattr(
+            pyfuncitem, "regtest_stream"
+        ):
+            sys.stdout = pyfuncitem.regtest_stream
+        yield
+        sys.stdout = stdout
 
-        orig_identifer, recorded_output_path = result_file_paths(
-            test_folder, item.nodeid, identifier
-        )
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_report_teststatus(self, report, config):
+        outcome = yield
+        if report.when == "call" and "uses-regtest" in report.keywords:
+            if config.getvalue("--regtest-reset"):
+                result = outcome.get_result()
+                if result[0] != "failed":
+                    outcome.force_result((result[0], "R", "RESET"))
 
-        reset = config.getvalue("--regtest-reset")
 
-        if reset:
-            os.makedirs(recorded_output_path, exist_ok=True)
-            handler.save(recorded_output_path, obj)
-            if orig_identifer is not None:
-                self._reset_regtest_outputs.append(recorded_output_path + ".item")
-                with open(recorded_output_path + ".item", "w") as fh:
-                    print(orig_identifer, file=fh)
-            self._reset_regtest_outputs.append(recorded_output_path)
-            return True, True, None
+class PytestRegtestPlugin:
+    def __init__(self, recorder):
+        self.recorder = recorder
 
-        has_markup = item.config.get_terminal_writer().hasmarkup
-        if os.path.exists(recorded_output_path):
-            recorded_obj = handler.load(recorded_output_path)
-            ok = handler.compare(obj, recorded_obj)
-            if ok:
-                return True, True, None
-            msg = handler.show_differences(obj, recorded_obj, has_markup)
-            return True, False, msg
+    @pytest.hookimpl(trylast=True)
+    def pytest_runtest_call(self, item):
+        if hasattr(item, "regtest_stream"):
+            output_exception = self.check_recorded_output(item)
+            if output_exception is not None:
+                raise output_exception
 
-        msg = handler.show(obj)
-        return False, False, msg
+        if item.get_closest_marker("xfail") and item.config.getvalue("--regtest-reset"):
+            # enforce consistency with xfail:
+            assert False
 
     def check_recorded_output(self, item):
         test_folder = item.fspath.dirname
         regtest_stream = item.regtest_stream
-        identifier = regtest_stream.identifier
+        version = regtest_stream.version or regtest_stream.identifier
+        if not isinstance(regtest_stream, RegtestStream):
+            return
 
         orig_identifer, recorded_output_path = result_file_paths(
-            test_folder, item.nodeid, identifier
+            test_folder, item.nodeid, version
         )
         config = item.config
 
@@ -131,10 +132,12 @@ class PytestRegtestPlugin:
             with open(recorded_output_path + ".out", "w", encoding="utf-8") as fh:
                 fh.write("".join(regtest_stream.get_lines()))
             if orig_identifer is not None:
-                self._reset_regtest_outputs.append(recorded_output_path + ".item")
+                self.recorder._reset_regtest_outputs.append(
+                    recorded_output_path + ".item"
+                )
                 with open(recorded_output_path + ".item", "w") as fh:
                     print(orig_identifer, file=fh)
-            self._reset_regtest_outputs.append(recorded_output_path + ".out")
+            self.recorder._reset_regtest_outputs.append(recorded_output_path + ".out")
             return
 
         if os.path.exists(recorded_output_path + ".out"):
@@ -154,7 +157,7 @@ class PytestRegtestPlugin:
             tobe = [line.rstrip() for line in tobe]
 
         if current != tobe:
-            self._failed_regtests.append(item)
+            self.recorder._failed_regtests.append(item)
             return RecordedOutputException(
                 current,
                 tobe,
@@ -163,44 +166,6 @@ class PytestRegtestPlugin:
                 recorded_output_file_exists,
             )
 
-    @pytest.hookimpl(hookwrapper=True)
-    def pytest_pyfunc_call(self, pyfuncitem):
-        stdout = sys.stdout
-        if "regtest_all" in pyfuncitem.fixturenames and hasattr(
-            pyfuncitem, "regtest_stream"
-        ):
-            sys.stdout = pyfuncitem.regtest_stream
-        yield
-        sys.stdout = stdout
-
-    @pytest.hookimpl(hookwrapper=True)
-    def pytest_report_teststatus(self, report, config):
-        outcome = yield
-        if report.when == "call" and "uses-regtest" in report.keywords:
-            if config.getvalue("--regtest-reset"):
-                result = outcome.get_result()
-                if result[0] != "failed":
-                    outcome.force_result((result[0], "R", "RESET"))
-
-    def pytest_terminal_summary(self, terminalreporter, exitstatus, config):
-        terminalreporter.ensure_newline()
-        terminalreporter.section("pytest-regtest report", sep="-", blue=True, bold=True)
-        terminalreporter.write("total number of failed regression tests: ", bold=True)
-        terminalreporter.line(str(len(self._failed_regtests)))
-        if config.getvalue("--regtest-reset"):
-            if config.option.verbose:
-                terminalreporter.line(
-                    "the following output files have been reset:", bold=True
-                )
-                for path in self._reset_regtest_outputs:
-                    rel_path = os.path.relpath(path)
-                    terminalreporter.line("  " + rel_path)
-            else:
-                terminalreporter.write(
-                    "total number of reset output files: ", bold=True
-                )
-                terminalreporter.line(str(len(self._reset_regtest_outputs)))
-
     @pytest.hookimpl(hookwrapper=True)
     def pytest_runtest_makereport(self, item, call):
         outcome = yield
@@ -216,57 +181,187 @@ class PytestRegtestPlugin:
                     line = line.ljust(tw.fullwidth, "-")
                     tw.line(line, green=True)
                     tw.write(item.regtest_stream.get_output() + "\n", cyan=True)
-
-                snapshots = item.regtest_stream.snapshots
-                if snapshots:
-                    tw.line()
-                    line = "recorded snapshots: "
-                    line = line.ljust(tw.fullwidth, "-")
+                    line = "-" * tw.fullwidth
                     tw.line(line, green=True)
-                    path = item.fspath.relto(item.session.fspath)
-                    code_lines = item.fspath.readlines()
-
-                    for obj, handler_options, line_no in snapshots:
-                        info = code_lines[line_no - 1].strip()
-                        tw.line(f"> {path} +{line_no}")
-                        tw.line(f"> {info}")
-                        handler = get_snapshot_handler(
-                            obj, handler_options, item.config
-                        )
-                        lines = handler.show(obj)
-                        for line in lines:
-                            tw.line(line, cyan=True)
-                if output or snapshots:
-                    tw.line("-" * tw.fullwidth, green=True)
-                    tw.line()
-                    tw.flush()
 
-        if call.when != "call" or not hasattr(item, "regtest_stream"):
+        if call.when != "call" or not getattr(item, "regtest", False):
             return
 
         result.keywords["uses-regtest"] = True
 
         if call.excinfo is not None:
-            if call.excinfo.type is RegtestException:
-                output_exception, snapshot_exception = call.excinfo.value.args
-                all_lines, all_colors = [], []
+            all_lines, all_colors = [], []
+            if call.excinfo.type is RecordedOutputException:
+                output_exception = call.excinfo
                 if output_exception is not None:
                     lines, colors = self._handle_regtest_exception(
-                        item, output_exception.args, result
+                        item, output_exception.value.args, result
                     )
                     all_lines.extend(lines)
                     all_colors.extend(colors)
+
+            else:
+                return
+
+            result.longrepr = CollectErrorRepr(all_lines, all_colors)
+
+    def _handle_regtest_exception(self, item, exc_args, result):
+        (
+            current,
+            recorded,
+            recorded_output_path,
+            regtest_stream,
+            recorded_output_file_exists,
+        ) = exc_args
+
+        nodeid = item.nodeid + (
+            "" if regtest_stream.version is None else "__" + regtest_stream.version
+        )
+        if not recorded_output_file_exists:
+            msg = "\nregression test output not recorded yet for {}:\n".format(nodeid)
+            return (
+                [msg] + current,
+                [dict()] + len(current) * [dict(red=True, bold=True)],
+            )
+
+        nodiff = item.config.getvalue("--regtest-nodiff")
+        diffs = list(
+            difflib.unified_diff(current, recorded, "current", "expected", lineterm="")
+        )
+
+        msg = "\nregression test output differences for {}:\n".format(nodeid)
+
+        if nodiff:
+            msg_diff = f"    {len(diffs)} lines in diff"
+        else:
+            recorded_output_path = os.path.relpath(recorded_output_path)
+            msg += f"    (recorded output from {recorded_output_path})\n"
+            msg_diff = "    >   " + "\n    >   ".join(diffs)
+
+        return [msg, msg_diff + "\n"], [dict(), dict(red=True, bold=True)]
+
+
+class SnapshotPlugin:
+    def __init__(self, recorder):
+        self.recorder = recorder
+
+    @pytest.hookimpl(trylast=True)
+    def pytest_runtest_call(self, item):
+        if hasattr(item, "snapshot"):
+            snapshot_exception = self.check_snapshots(item)
+            if snapshot_exception is not None:
+                raise snapshot_exception
+
+        if item.get_closest_marker("xfail") and item.config.getvalue("--regtest-reset"):
+            # enforce fail
+            assert False
+
+    def check_snapshots(self, item):
+        results = []
+
+        any_failed = False
+        for idx, snapshot in enumerate(item.snapshot.snapshots):
+            is_recorded, ok, msg = self.check_snapshot(idx, item, snapshot)
+            if not ok:
+                any_failed = True
+            results.append((ok, snapshot, is_recorded, msg))
+
+        if any_failed:
+            self.recorder._failed_snapshots.append(item)
+            return SnapshotException(results)
+
+    def check_snapshot(self, idx, item, snapshot):
+        obj, version, handler_options, _ = snapshot
+        handler = get_snapshot_handler(obj, handler_options, item.config)
+
+        test_folder = item.fspath.dirname
+        if version is not None:
+            identifier = str(version) + "__" + str(idx)
+        else:
+            identifier = str(idx)
+
+        config = item.config
+
+        orig_identifer, recorded_output_path = result_file_paths(
+            test_folder, item.nodeid, identifier
+        )
+
+        reset = config.getvalue("--regtest-reset")
+
+        if reset:
+            os.makedirs(recorded_output_path, exist_ok=True)
+            handler.save(recorded_output_path, obj)
+            if orig_identifer is not None:
+                self.recorder._reset_snapshots.append(recorded_output_path + ".item")
+                with open(recorded_output_path + ".item", "w") as fh:
+                    print(orig_identifer, file=fh)
+            self.recorder._reset_snapshots.append(recorded_output_path)
+            return True, True, None
+
+        has_markup = item.config.get_terminal_writer().hasmarkup
+        if os.path.exists(recorded_output_path):
+            recorded_obj = handler.load(recorded_output_path)
+            ok = handler.compare(obj, recorded_obj)
+            if ok:
+                return True, True, None
+            msg = handler.show_differences(obj, recorded_obj, has_markup)
+            return True, False, msg
+
+        msg = handler.show(obj)
+        return False, False, msg
+
+    @pytest.hookimpl(hookwrapper=True)
+    def pytest_runtest_makereport(self, item, call):
+        outcome = yield
+        result = outcome.get_result()
+        if call.when == "teardown" and hasattr(item, "snapshot"):
+            if item.config.getvalue("--regtest-tee"):
+                tw = TerminalWriter()
+                snapshots = item.snapshot.snapshots
+                if not snapshots:
+                    return
+
+                tw.line()
+                line = "recorded snapshots: "
+                line = line.ljust(tw.fullwidth, "-")
+                tw.line(line, green=True)
+                path = item.fspath.relto(item.session.fspath)
+                code_lines = item.fspath.readlines()
+
+                for obj, version, handler_options, line_no in snapshots:
+                    info = code_lines[line_no - 1].strip()
+                    tw.line(f"> {path} +{line_no}")
+                    tw.line(f"> {info}")
+                    handler = get_snapshot_handler(obj, handler_options, item.config)
+                    lines = handler.show(obj)
+                    for line in lines:
+                        tw.line(line, cyan=True)
+                tw.line("-" * tw.fullwidth, green=True)
+                tw.line()
+                tw.flush()
+
+        if call.when != "call" or not hasattr(item, "snapshot"):
+            return
+
+        result.keywords["uses-regtest"] = True
+
+        if call.excinfo is not None:
+            all_lines, all_colors = [], []
+            if call.excinfo.type is SnapshotException:
+                snapshot_exception = call.excinfo
                 if snapshot_exception is not None:
                     lines, colors = self._handle_snapshot_exception(
-                        item, snapshot_exception.args, result
+                        item, snapshot_exception.value.args, result
                     )
                     all_lines.extend(lines)
                     all_colors.extend(colors)
+            else:
+                return
 
-                result.longrepr = CollectErrorRepr(all_lines, all_colors)
+            result.longrepr = CollectErrorRepr(all_lines, all_colors)
 
     def _handle_snapshot_exception(self, item, exc_args, result):
-        regtest_stream = item.regtest_stream
+        snapshot = item.snapshot
         lines = []
         colors = []
 
@@ -276,17 +371,12 @@ class PytestRegtestPlugin:
         RED = dict(red=True, bold=True)
         GREEN = dict(green=True, bold=False)
 
-        nodeid = item.nodeid + (
-            ""
-            if regtest_stream.identifier is None
-            else "__" + regtest_stream.identifier
-        )
-        headline = "\nsnapshot error(s) for {}:".format(nodeid)
+        headline = "\nsnapshot error(s) for {}:".format(item.nodeid)
         lines.append(headline)
         colors.append(NO_COLOR)
 
         for ok, snapshot, is_recorded, msg in exc_args[0]:
-            obj, kw, line_no = snapshot
+            obj, version, kw, line_no = snapshot
             info = code_lines[line_no - 1].strip()
 
             path = item.fspath.relto(item.session.fspath)
@@ -322,45 +412,8 @@ class PytestRegtestPlugin:
 
         return lines, colors
 
-    def _handle_regtest_exception(self, item, exc_args, result):
-        (
-            current,
-            recorded,
-            recorded_output_path,
-            regtest_stream,
-            recorded_output_file_exists,
-        ) = exc_args
 
-        nodeid = item.nodeid + (
-            ""
-            if regtest_stream.identifier is None
-            else "__" + regtest_stream.identifier
-        )
-        if not recorded_output_file_exists:
-            msg = "\nregression test output not recorded yet for {}:\n".format(nodeid)
-            return (
-                [msg] + current,
-                [dict()] + len(current) * [dict(red=True, bold=True)],
-            )
-
-        nodiff = item.config.getvalue("--regtest-nodiff")
-        diffs = list(
-            difflib.unified_diff(current, recorded, "current", "expected", lineterm="")
-        )
-
-        msg = "\nregression test output differences for {}:\n".format(nodeid)
-
-        if nodiff:
-            msg_diff = f"    {len(diffs)} lines in diff"
-        else:
-            recorded_output_path = os.path.relpath(recorded_output_path)
-            msg += f"    (recorded output from {recorded_output_path})\n"
-            msg_diff = "    >   " + "\n    >   ".join(diffs)
-
-        return [msg, msg_diff + "\n"], [dict(), dict(red=True, bold=True)]
-
-
-def result_file_paths(test_folder, nodeid, identifier):
+def result_file_paths(test_folder, nodeid, version):
     file_path, __, test_function_name = nodeid.partition("::")
     file_name = os.path.basename(file_path)
 
@@ -381,8 +434,8 @@ def result_file_paths(test_folder, nodeid, identifier):
 
     test_function_name = test_function_name.replace(" ", "_")
     stem, __ = os.path.splitext(file_name)
-    if identifier is not None:
-        output_file_name = stem + "." + test_function_name + "__" + identifier
+    if version is not None:
+        output_file_name = stem + "." + test_function_name + "__" + str(version)
     else:
         output_file_name = stem + "." + test_function_name
 
@@ -394,16 +447,14 @@ def result_file_paths(test_folder, nodeid, identifier):
 class RegtestStream:
     def __init__(self, request):
         request.node.regtest_stream = self
+        request.node.regtest = True
         self.request = request
         self.buffer = StringIO()
+        self.version = None
         self.identifier = None
 
         self.snapshots = []
 
-    def check(self, obj, **kw):
-        line_no = inspect.currentframe().f_back.f_lineno
-        self.snapshots.append((obj, kw, line_no))
-
     def write(self, what):
         self.buffer.write(what)
 
@@ -430,6 +481,20 @@ class RegtestStream:
         return False  # dont suppress exception
 
 
+class Snapshot:
+    def __init__(self, request):
+        request.node.snapshot = self
+        request.node.regtest = True
+        self.request = request
+        self.buffer = StringIO()
+
+        self.snapshots = []
+
+    def check(self, obj, *, version=None, **kw):
+        line_no = inspect.currentframe().f_back.f_lineno
+        self.snapshots.append((obj, version, kw, line_no))
+
+
 def cleanup(output, request):
     for converter in _converters_pre:
         output = converter(output, request)
@@ -461,7 +526,8 @@ _converters_pre = []
 _converters_post = []
 
 
-def clear_converters():
+def clear_converters() -> None:
+    """Unregisters all converters, including the builtin converters."""
     _converters_pre.clear()
     _converters_post.clear()
 
@@ -474,7 +540,20 @@ def _fix_pre_v2_converter_function(function):
     return fixed_converter_function
 
 
-def register_converter_pre(function):
+def register_converter_pre(
+    function: Callable[[str, Optional[_pytest.fixtures.FixtureRequest]], None],
+) -> None:
+    """Registers a new conversion function at the head of the list
+    of existing converters.
+
+    Parameters:
+        function: Function to cleanup given string and remove data which can change
+                  between test runs without affecting the correctness of the test.
+                  The second argument is optional and is a `pytest` object which holds
+                  information about the current `config` or the current test function.
+                  This argument can be ignored in many situations.
+
+    """
     if function not in _converters_pre:
         signature = inspect.signature(function)
         # keep downward compatibility:
@@ -483,7 +562,19 @@ def register_converter_pre(function):
         _converters_pre.append(function)
 
 
-def register_converter_post(function):
+def register_converter_post(
+    function: Callable[[str, Optional[_pytest.fixtures.FixtureRequest]], None],
+) -> None:
+    """Registers a new conversion function at the head of the list
+    of existing converters
+
+    Parameters:
+        function: Function to cleanup given string and remove data which can change
+                  between test runs without affecting the correctness of the test.
+                  The second argument is optional and is a `pytest` object which holds
+                  information about the current `config` or the current test function.
+                  This argument can be ignored in many situations.
+    """
     if function not in _converters_post:
         signature = inspect.signature(function)
         # keep downward compatibility:
@@ -543,7 +634,7 @@ class CollectErrorRepr(TerminalRepr):
 
 
 def get_snapshot_handler(obj, handler_options, pytest_config):
-    for check, handler in snapshot_handlers:
-        if check(obj):
-            return handler(handler_options, pytest_config, tw)
-    raise ValueError(f"cannot take snapshot for type {obj.__class__}")
+    handler = SnapshotHandlerRegistry.get_handler(obj)
+    if handler is None:
+        raise ValueError(f"cannot take snapshot for type {obj.__class__}")
+    return handler(handler_options, pytest_config, tw)

pytest_regtest/register_third_party_handlers.py

@@ -1,20 +1,4 @@
-try:
-    import numpy as np  # noqa: F401
-
-    HAS_NUMPY = True
-except ImportError:
-    HAS_NUMPY = False
-
-try:
-    import pandas as pd  # noqa: F401
-
-    HAS_PANDAS = True
-except ImportError:
-    HAS_PANDAS = False
-
-
-if HAS_PANDAS and HAS_NUMPY:
-
+def register_pandas_handler():
     def is_dataframe(obj):
         try:
             import pandas as pd
@@ -24,12 +8,12 @@ if HAS_PANDAS and HAS_NUMPY:
             return False
 
     from .pandas_handler import DataFrameHandler
-    from .snapshot_handler import snapshot_handlers
+    from .snapshot_handler import SnapshotHandlerRegistry
 
-    snapshot_handlers.append((is_dataframe, DataFrameHandler))
+    SnapshotHandlerRegistry.add_handler(is_dataframe, DataFrameHandler)
 
-if HAS_NUMPY:
 
+def register_numpy_handler():
     def is_numpy(obj):
         try:
             import numpy as np
@@ -39,6 +23,6 @@ if HAS_NUMPY:
             return False
 
     from .numpy_handler import NumpyHandler
-    from .snapshot_handler import snapshot_handlers
+    from .snapshot_handler import SnapshotHandlerRegistry
 
-    snapshot_handlers.append((is_numpy, NumpyHandler))
+    SnapshotHandlerRegistry.add_handler(is_numpy, NumpyHandler)