Feature request: add possibility to launch differs blocking

[obestwalter]

As seen in #93 there are tools that make it necessary to run the differ blocking to even be able to use approvaltests.

I would also add that it might be a workflow preference to have the differ block until it is close by the user to be able to work through a series of failures one by one rather than to have them pop open all at the same time. This is definitely a mater of taste though, but together with the above problem could make the case that a possibility to configure might make sense.

I would be willing to prepare (or help preparing) a patch.

[matthiasschaub]

In the case of the reporter being a GUI which pops up, I am also in favor of this reporter being blocking just so that there are not many pop-ups at the same time.

There are also scenarios when implementing a custom reporter that the reporter needs to be blocking. This is the case when the reporter needs to do cleanup after successful reporting.
E.g. A reporter creates an image representation of the JSON being verified. The reporter writes the image to disk for it to be opened in a GUI (Pycharm Diff Tool). After the GUI is closed again this image should be deleted.

I find this library very useful. Thanks for all the work!

[matthiasschaub]

Are you interested in a PR making reporter blocking? Either optionally or by default?

Currently, we do two things to make reporters blocking:

One is calling subprocess.run instead of subprocess.Popen:

class BlockingGenericDiffReporter(GenericDiffReporter):
    @staticmethod
    def run_command(command_array: list[str]):
        # Use run instead of Popen which waits for process to finish
        subprocess.run(command_array)

The other is opening programs on MacOS using /usr/bin/open -W -n (-W for wait until the application is closed. -n for new instance).

class ReportWithPyCharmProfessionalMacOS(BlockingGenericDiffReporter):
    def __init__(self):
        super().__init__(
            config=GenericDiffReporterConfig(
                name="ReportWithPyCharmProfessionalMacOS",
                # Use open to block Python until diff tool is closed again
                path="/usr/bin/open",
                extra_args=[
                    # -W: Wait until the application is closed
                    "-W",
                    # -n: new instance
                    "-n",
                    # -a: application
                    "-a",
                    "/Applications/PyCharm Professional Edition.app/Contents/MacOS/pycharm",  # noqa
                    "--args",
                    "diff",
                ],
            )
        )

In the second case, one needs to check if opening the application errors (in addition to check if the program executable exists, since /usr/bin/open always exists):

class BlockingGenericDiffReporter(GenericDiffReporter):
    @staticmethod
    def run_command(command_array: list[str]):
        # Use run instead of Popen which waits for process to finish
        subprocess.run(command_array)

    def report(self, *args, **kwargs) -> bool:
        # Wrap report func to catch failure of programs which open/start other
        # programs like `open` on MacOS and `xdg-open` on Linux
        try:
            return super().report(*args, **kwargs)
        except subprocess.CalledProcessError:
            return False

[JayBazuzi]

bump to top