Test conditional import code

[anatoli26]

In my package I'm checking for an extra dependency with a code like this:

try:
    import typer
except ImportError:
    print("error: typer not installed", file=sys.stderr)
    sys.exit(1)

Can't find a way to test this. Patching "builtins.__import__" with a temporary mock_import works only if no previous import typer calls were made.

So if invoking pytest test_dynamic_import.py, it's working, but bare pytest analyzes and performs imports in other testfiles that import the main package where the dynamic import code is executed, so typer is already imported when the test function with the patch code in the test_dynamic_import.py file is invoked.

I believe there should be a more straightforward method to test for dynamic imports. Please, advise.

[portyu9]

Hi @anatoli26

The difficulty here is that you're trying to simulate a first import inside a pytest process where that dependency may already have been imported.

Python caches imported modules in:

sys.modules

and pytest also loads plugins and other test modules during startup/collection. If something else has already imported typer, patching builtins.__import__ later is not a reliable simulation of:

try:
    import typer
except ImportError:
    ...

The most reliable test for import-time behavior is therefore an isolated Python subprocess.

For example:

import subprocess
import sys


def test_missing_typer():
    result = subprocess.run(
        [
            sys.executable,
            "-c",
            """
import builtins

real_import = builtins.__import__

def fake_import(name, *args, **kwargs):
    if name == "typer":
        raise ImportError("simulated missing dependency")
    return real_import(name, *args, **kwargs)

builtins.__import__ = fake_import

import your_package
""",
        ],
        capture_output=True,
        text=True,
    )

    assert result.returncode == 1
    assert "typer not installed" in result.stderr

That gives you a fresh interpreter whose import state isn't affected by pytest or its plugins.

You can attempt this in-process by removing your own module from sys.modules and then importing it again while __import__ is patched:

import importlib
import sys


def test_missing_typer(monkeypatch):
    sys.modules.pop("your_package", None)

    real_import = __import__

    def fake_import(name, *args, **kwargs):
        if name == "typer":
            raise ImportError("simulated")
        return real_import(name, *args, **kwargs)

    monkeypatch.setattr("builtins.__import__", fake_import)

    importlib.import_module("your_package")

but I would avoid deleting typer and all of its submodules from sys.modules, because another pytest plugin may legitimately depend on them.

If you control the application code, an even cleaner design is to move the dependency check out of module-import side effects and into a callable. That lets you unit-test the behavior without manipulating Python's import system.

For this particular case, though, a subprocess is the closest test of what actually happens when a user starts your package without typer installed.

Please mark this answer as accepted if it helped, thank you.