Pytest: Comment tester une fonction de saisie de l'appel?

J'ai une console de programme écrit en Python. Il demande à l'utilisateur de questions à l'aide de la commande:

some_input = input('Answer the question:', ...)

Comment pourrais-je tester une fonction contenant un appel à input à l'aide de pytest?
Je ne voudrais pas forcer un testeur de saisie de texte à plusieurs reprises seulement de terminer une série de tests.

  • Avez-vous regarder à travers des tutoriels sur la façon d'utiliser pytest pour voir ce que vous pouvez essayer? C'est une assez vaste question à se poser.
  • Pas récemment. J'ai utilisé pytest avant, mais il est venu à mon esprit quand penser à faire du TDD pour mon projet ici et je n'ai aucune idée de comment le résoudre. Je vais jeter un oeil à ceux-tuts de nouveau.
  • Dans votre fonction de test, vous pouvez réaffecter les input() la fonction de quelque chose d'autre (aussi connu comme "monkey patching" ou de "shadowing").
  • Pas une mauvaise idée, qui pourrait être la voie.
  • Relative (sans doublon): stackoverflow.com/questions/6271947/...
InformationsquelleAutor Zelphir Kaltstahl | 2016-03-07
  1. 15

    Vous devriez probablement se moquer de l'intégré dans entrée fonction, vous pouvez utiliser le permutation fonctionnalités fournies par pytest pour revenir à l'original input fonction après chaque test.

    import module  # The module which contains the call to input

class TestClass:

    def test_function_1(self):
        # Override the Python built-in input method 
        module.input = lambda: 'some_input'
        # Call the function you would like to test (which uses input)
        output = module.function()  
        assert output == 'expected_output'

    def test_function_2(self):
        module.input = lambda: 'some_other_input'
        output = module.function()  
        assert output == 'another_expected_output'        

    def teardown_method(self, method):
        # This method is being called after each test case, and it will revert input back to original function
        module.input = input

    Une solution plus élégante serait d'utiliser la faux module avec un avec l'instruction. De cette façon, vous n'avez pas besoin d'utiliser le démontage et le patché méthode ne pourra vivre dans la with portée.

    import mock
import module

def test_function():
    with mock.patch.object(__builtins__, 'input', lambda: 'some_input'):
        assert module.function() == 'expected_output'
    • Serait-ce possible de changer la fonction derrière input pour l'ensemble de la session de test, ou seulement pour ce un test?
    • Non, ce serait aussi le patch input pour quoi que ce soit en cours d'exécution après ce test. Vous devez utiliser à la place pytest du monkeypatch luminaire à l'inverse automatiquement les correctifs à la fin de l'essai.
    • Merci @TheCompiler, j'ai édité ma question.
    • "ma question" ? ^^
    • Ah désolé, je ne vous demandez-vous à quoi vous faisiez référence à votre question. Peut-être que vous avez posté une question similaire ou connexe question quelque part, mais n'a pas un lien ou quelque chose.
    • Ce n'est pas clair pour moi. Où est le test? Quand le teardown_method appelée? Peut-être que vous pouvez mettre plus de détail dans votre réponse.
    • J'ai mis à jour pour répondre à vos questions. J'espère que c'est plus clair de cette façon, laissez-moi savoir si vous avez des questions.
    • Il devrait être __builtins__ pas __builtin__

    InformationsquelleAutor Forge
  2. 27

    Que Le Compilateur a suggéré, pytest a une nouvelle monkeypatch luminaire pour cela. Un monkeypatch objet peut modifier un attribut dans une classe ou une valeur dans un dictionnaire, puis de restaurer sa valeur d'origine à la fin de l'essai.

    Dans ce cas, le haut- input fonction est une valeur de python __builtins__ dictionnaire, on peut donc le modifier comme suit:

    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"
    • Cela devrait être setattr, pas setitem.
    InformationsquelleAutor mareoraft
  3. 14

    Vous pouvez remplacer sys.stdin avec quelques personnalisé Texte IO, comme les entrées à partir d'un fichier ou d'un mémoire StringIO tampon:

    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

    c'est plus robuste que seuls les correctifs input(), tant que cela ne sera pas suffisant si le module utilise des autres modes de consommation de texte à partir de stdin.

    Cela peut aussi être fait assez élégamment avec un gestionnaire de contexte

    import sys
from contextlib import contextmanager

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

    Et puis il suffit de l'utiliser comme ceci par exemple:

    with replace_stdin(StringIO("some preprogrammed input")):
    module.call_function()
    InformationsquelleAutor Felk
  4. 3

    Vous pouvez le faire avec mock.patch comme suit.

    Tout d'abord, dans votre code, créer un mannequin de fonction pour les appels à input:

    def __get_input(text):
    return input(text)

    Dans vos fonctions de test:

    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

    Par exemple, si vous avez une boucle de vérifier que les seules réponses valables sont dans ['y', 'Y', 'n', 'N'] vous pouvez tester que rien ne se passe lors de la saisie d'une valeur différente à la place.

    Dans ce cas, nous supposons que les SystemExit est déclenché lorsque vous répondez '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
    InformationsquelleAutor fernandezcuesta
  5. 1

    Cela peut être fait avec mock.patch et with blocs en 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'

    La ligne de la note est mock.patch.object(builtins, 'input', lambda _: '19'):, qui remplace la input avec la fonction lambda. Notre fonction lambda prend dans une poubelle variable _ parce que input prend en argument.

    Voici comment vous pouvez tester les cas d'échec, où user_input appels sys.exit. L'astuce ici est d'obtenir pytest à regarder pour que l'exception 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()

    Vous devriez être en mesure d'obtenir ce test en cours d'exécution par copier et de coller le code ci-dessus dans un fichier tests/test_.py et en cours d'exécution pytest du parent dir.

    InformationsquelleAutor AlexG