How to unittest local variable in Python

I had to unit test by mocking a local variable which held a function, so doctest and unittest can both use these ways to mock/test a local variable, function or not:

"""Mocking a local function in doctest and unittest, by Cees Timmerman 2025-03-22.
Also checks a variable in a static function for https://stackoverflow.com/q/23909692/819417

>>> 'some_local_var_in_this_static_function = "hello"' in inspect.getsource(get_input)
True
"""

import inspect
import sys
import unittest
from typing import Callable


def get_input() -> str:
    """How static is assigning to a temp var? Very; immutable is different in this context.
    >>> _ = get_input()
    """
    some_local_var_in_this_static_function = "hello"

    # Static runtime integrity check.
    if some_local_var_in_this_static_function != "hello":
        raise ValueError("Runtime panic! The static function get_input is corrupt!")

    # Static test time integrity check.
    if "doctest.py" in str(sys.modules["__main__"].__file__) or "unittest" in str(sys.modules["__main__"].__file__):
        if some_local_var_in_this_static_function != "hello":
            raise ValueError(
                "Unit test fail! The static function get_input is corrupt!"
            )

    return input()


def way_a(x: Callable[[], str] = get_input) -> str:
    """
    >>> way_a(lambda: "42")
    '42'
    """
    return x()


def way_b() -> str:
    """
    >>> way_b()
    '42'
    """
    global get_input

    local_backup = get_input
    if "doctest.py" in str(sys.modules["__main__"].__file__):
        get_input = lambda: "42"
    rv = get_input()
    # Assume all the usage of variable get_input has been sufficiently mocked, so restore regular function for the rest of this program.
    get_input = local_backup
    return rv


class TestWays(unittest.TestCase):

    def test_way_a(self) -> None:
        self.assertEqual(way_a(lambda: "42"), "42")

    def test_way_b(self) -> None:
        global get_input
        get_input = lambda: "42"
        self.assertEqual(way_b(), "42")

    def test_local_function_var(self) -> None:
        self.assertTrue(
            'some_local_var_in_this_static_function = "hello"'
            in inspect.getsource(get_input)
        )

    def test_just_run_it(self) -> None:
        get_input()


if __name__ == "__main__":
    way_a()
    way_b()

>python test_doctest_mock.py                
a
a

>python -m doctest -v test_doctest_mock.py  
Trying:
    'some_local_var_in_this_static_function = "hello"' in inspect.getsource(get_input)
Expecting:
    True
ok
Trying:
    _ = get_input()
Expecting nothing
a
ok
Trying:
    way_a(lambda: "42")
Expecting:
    '42'
ok
Trying:
    way_b()
Expecting:
    '42'
ok
5 items had no tests:
    test_doctest_mock.TestWays
    test_doctest_mock.TestWays.test_just_run_it
    test_doctest_mock.TestWays.test_local_function_var
    test_doctest_mock.TestWays.test_way_a
    test_doctest_mock.TestWays.test_way_b
4 items passed all tests:
   1 tests in test_doctest_mock
   1 tests in test_doctest_mock.get_input
   1 tests in test_doctest_mock.way_a
   1 tests in test_doctest_mock.way_b
4 tests in 9 items.
4 passed and 0 failed.
Test passed.

>python -m unittest -v test_doctest_mock.py
test_just_run_it (test_doctest_mock.TestWays) ... a
ok
test_local_function_var (test_doctest_mock.TestWays) ... ok
test_way_a (test_doctest_mock.TestWays) ... ok
test_way_b (test_doctest_mock.TestWays) ... ok

----------------------------------------------------------------------
Ran 4 tests in 2.034s

OK

Local vars can be tested locally from a detect unit test if block demonstrated in way_b. If the code you're replacing is external, you can use the mock.patch decorator as shown here.