As The Compiler suggested, pytest has a new monkeypatch fixture for this. A monkeypatch object can alter an attribute in a class or a value in a dictionary, and then restore its original value at the end of the test.

In this case, the built-in input function is a value of python’s __builtins__ dictionary, so we can alter it like so:

def test_something_that_involves_user_input(monkeypatch):

    # monkeypatch the "input" function, so that it returns "Mark".
    # This simulates the user entering "Mark" in the terminal:
    monkeypatch.setattr('builtins.input', lambda _: "Mark")

    # go about using input() like you normally would:
    i = input("What is your name?")
    assert i == "Mark"

You can replace sys.stdin with some custom Text IO, like input from a file or an in-memory StringIO buffer:

import sys

class Test:
    def test_function(self):
        sys.stdin = open("preprogrammed_inputs.txt")
        module.call_function()

    def setup_method(self):
        self.orig_stdin = sys.stdin

    def teardown_method(self):
        sys.stdin = self.orig_stdin

this is more robust than only patching input(), as that won’t be sufficient if the module uses any other methods of consuming text from stdin.

This can also be done quite elegantly with a custom context manager

import sys
from contextlib import contextmanager

@contextmanager
def replace_stdin(target):
    orig = sys.stdin
    sys.stdin = target
    yield
    sys.stdin = orig

And then just use it like this for example:

with replace_stdin(StringIO("some preprogrammed input")):
    module.call_function()

You can do it with mock.patch as follows.

First, in your code, create a dummy function for the calls to input:

def __get_input(text):
    return input(text)

In your test functions:

import my_module
from mock import patch

@patch('my_module.__get_input', return_value='y')
def test_what_happens_when_answering_yes(self, mock):
    """
    Test what happens when user input is 'y'
    """
    # whatever your test function does

For example if you have a loop checking that the only valid answers are in [‘y’, ‘Y’, ‘n’, ‘N’] you can test that nothing happens when entering a different value instead.

In this case we assume a SystemExit is raised when answering ‘N’:

@patch('my_module.__get_input')
def test_invalid_answer_remains_in_loop(self, mock):
    """
    Test nothing's broken when answer is not ['Y', 'y', 'N', 'n']
    """
    with self.assertRaises(SystemExit):
        mock.side_effect = ['k', 'l', 'yeah', 'N']
        # call to our function asking for input

This can be done with mock.patch and with blocks in python3.

import pytest
import mock
import builtins

"""
The function to test (would usually be loaded
from a module outside this file).
"""
def user_prompt():
    ans = input('Enter a number: ')
    try:
        float(ans)
    except:
        import sys
        sys.exit('NaN')
    return 'Your number is {}'.format(ans)

"""
This test will mock input of '19'
"""    
def test_user_prompt_ok():
    with mock.patch.object(builtins, 'input', lambda _: '19'):
        assert user_prompt() == 'Your number is 19'

The line to note is mock.patch.object(builtins, 'input', lambda _: '19'):, which overrides the input with the lambda function. Our lambda function takes in a throw-away variable _ because input takes in an argument.

Here’s how you could test the fail case, where user_input calls sys.exit. The trick here is to get pytest to look for that exception with pytest.raises(SystemExit).

"""
This test will mock input of 'nineteen'
"""    
def test_user_prompt_exit():
    with mock.patch.object(builtins, 'input', lambda _: 'nineteen'):
        with pytest.raises(SystemExit):
            user_prompt()

You should be able to get this test running by copy and pasting the above code into a file tests/test_.py and running pytest from the parent dir.

Since I need the input() call to pause and check my hardware status LEDs, I had to deal with the situation without mocking. I used the -s flag.

python -m pytest -s test_LEDs.py

The -s flag essentially means: shortcut for –capture=no.

You can also use environment variables in your test code. For example if you want to give path as argument you can read env variable and set default value if it’s missing.

import os
...
input = os.getenv('INPUT', default='inputDefault/')

Then start with default argument

pytest ./mytest.py

or with custom argument

INPUT=newInput/ pytest ./mytest.py

A different alternative that does not require using a lambda function and provides more control during the tests is to use the mock decorator from the standard unittest module.

It also has the additional advantage of patching just where the object (i.e. input) is looked up, which is the recommended strategy.

# path/to/test/module.py
def my_func():
    some_input = input('Answer the question:')
    return some_input

# tests/my_tests.py

from unittest import mock

from path.to.test.module import my_func

@mock.patch("path.to.test.module.input")
def test_something_that_involves_user_input(mock_input):
    mock_input.return_value = "This is my answer!"
    assert my_func() == "This is my answer!"
    mock_input.assert_called_once()  # Optionally check one and only one call   

I don’t have enough points to comment, but this answer: https://stackoverflow.com/a/55033710/10420225
doesn’t work if you just copy/pasta.

Part One

For Python3, import mock doesn’t work.

You need import unittest.mock and call it as unittest.mock.patch.object(), or from unittest import mock mock.patch.object()...

If using Python3.3+ the above should "just work". If using Python3.3- you need to pip install mock. See this answer for more info: https://stackoverflow.com/a/11501626/10420225

Part Two

Also, if you want to make this example more realistic, i.e. importing the function from outside the file and using it, there’s more assembly required.

This is general directory structure we’ll use

root/
  src/prompt_user.py
  tests/test_prompt_user.py

If function in external file

# /root/src/prompt_user.py
def user_prompt():
    ans = input("Enter a number: ")
    try:
        float(ans)
    except:
        import sys

        sys.exit("NaN")
    return "Your number is {}".format(ans)

# /root/tests/test_prompt_user.py
import pytest
from unittest import mock
import builtins

from prompt_user import user_prompt

def test_user_prompt_ok():
    with mock.patch.object(builtins, "input", lambda _: "19"):
        assert user_prompt() == "Your number is 19"

If function in a class in external file

# /root/src/prompt_user.py
class Prompt:
    def user_prompt(self):
        ans = input("Enter a number: ")
        try:
            float(ans)
        except:
            import sys

            sys.exit("NaN")
        return "Your number is {}".format(ans)

# /root/tests/test_prompt_user.py
import pytest
from unittest import mock
import builtins

from mocking_test import Prompt


def test_user_prompt_ok():
    with mock.patch.object(builtins, "input", lambda _: "19"):
        assert Prompt.user_prompt(Prompt) == "Your number is 19"

Hopefully this helps people a bit more. I find these very simple examples almost useless because it leaves a lot out for real world use cases.

Edit: If you run into pytest import issues when running from external files, I would recommend looking over this answer: PATH issue with pytest 'ImportError: No module named YadaYadaYada'

The simplest way that works without mocking and easily in doctest for lightweight testing, is just making the input_function a parameter to your function and passing in this FakeInput class with the appropriate list of inputs that you want:

class FakeInput:
    def __init__(self, input):
        self.input = input
        self.index = 0

    def __call__(self):
        line = self.input[self.index % len(self.input)]
        self.index += 1
        return line

Here is an example usage to test some functions using the input function:

import doctest

class FakeInput:
    def __init__(self, input):
        self.input = input
        self.index = 0

    def __call__(self):
        line = self.input[self.index % len(self.input)]
        self.index += 1
        return line
    
def add_one_to_input(input_func=input):
    """
    >>> add_one_to_input(FakeInput(['1']))
    2
    """
    return int(input_func()) + 1

def add_inputs(input_func=input):
    """
    >>> add_inputs(FakeInput(['1', '5']))
    6
    """
    return int(input_func()) + int(input_func())

def return_ten_inputs(input_func=input):
    """
    >>> return_ten_inputs(FakeInput(['1', '5', '7']))
    [1, 5, 7, 1, 5, 7, 1, 5, 7, 1]
    """
    return [int(input_func()) for _ in range(10)]

def print_4_inputs(input_func=input):
    """
    >>> print_4_inputs(FakeInput(['1', '5', '7']))
    1
    5
    7
    1
    """
    for i in range(4):
        print(input_func())

if __name__ == '__main__':
    doctest.testmod()

This also makes your functions more general so you can easily change them to take input from a file rather than the keyboard.