Python mocking rohe Eingabe in Unittests

Okay, zunächst, ich denke, es ist notwendig zu betonen, dass in den original-code in Frage, es gibt tatsächlich zwei Dinge, die angegangen werden müssen:

1. raw_input (ein Eingang Nebenwirkung) muss verspottet werden.
2. print (ein Ausgang Nebenwirkung) muss überprüft werden.

In eine ideale Funktion für unit-Tests, gäbe es keine Nebenwirkungen. Eine Funktion würde einfach getestet werden, indem er in den Argumenten und Ihrer Ausgabe würde überprüft werden. Aber oft wollen wir für den test von Funktionen, die nicht ideal sind, DH, in der Funktionen wie Ihnen.

Also, was sollen wir tun? Naja, in Python 3.3, die beide die Probleme, die ich oben aufgeführt wurde trivial, weil die unittest Moduls die Fähigkeit erworben, zu verspotten und zu überprüfen für Nebenwirkungen. Aber, wie der start ins neue Jahr 2014, nur 30% der Python-Programmierer hatte, verschoben auf 3.x, so dass für das wohl der anderen 70% der Python-Programmierer immer noch mit 2.x werde ich skizzieren, eine Antwort. Bei der aktuellen rate, 3.x nicht überholen 2.x bis ~2019, und 2.x wird nicht verschwinden, bis ~2027. Also ich finde diese Antwort nützlich sein wird für mehrere Jahre zu kommen.

Möchte ich zu den Fragen oben aufgeführt, ein zu einer Zeit, also werde ich zunächst ändern Sie Ihre Funktion mit print als Ausgabe zu verwenden return. Keine überraschungen, hier ist das code:

def answerReturn():
    ans = raw_input('enter yes or no')
    if ans == 'yes':
        return 'you entered yes'
    if ans == 'no':
        return 'you entered no'

Also alles, was wir tun müssen, ist mock raw_input. Einfach genug - Omid Raha Antwort auf diese Frage zeigt uns, wie zu tun, dass durch swizzling aus der __builtins__.raw_input Umsetzung mit unseren mock-Implementierung. Außer seine Antwort war nicht richtig organisiert in einem TestCase und Funktionen, so werde ich zeigen, dass.

import unittest    

class TestAnswerReturn(unittest.TestCase):
    def testYes(self):
        original_raw_input = __builtins__.raw_input
        __builtins__.raw_input = lambda _: 'yes'
        self.assertEqual(answerReturn(), 'you entered yes')
        __builtins__.raw_input = original_raw_input

    def testNo(self):
        original_raw_input = __builtins__.raw_input
        __builtins__.raw_input = lambda _: 'no'
        self.assertEqual(answerReturn(), 'you entered no')
        __builtins__.raw_input = original_raw_input

Kleine Anmerkung nur auf Python-Namenskonventionen - Variablen, die erforderlich sind, durch den parser aber nicht verwendet werden, sind in der Regel benannt _, wie im Fall der lambda-nicht verwendete variable (die normalerweise von der Eingabeaufforderung angezeigt, um den Benutzer im Fall der raw_input, incase Sie sich Fragen, warum es überhaupt erfordert, in diesem Fall).

Sowieso, das ist unübersichtlich und redundant. Ich werde also tun, Weg mit der Wiederholung, indem man eine contextmanager, die es erlauben, für einfache with Aussagen.

from contextlib import contextmanager

@contextmanager
def mockRawInput(mock):
    original_raw_input = __builtins__.raw_input
    __builtins__.raw_input = lambda _: mock
    yield
    __builtins__.raw_input = original_raw_input

class TestAnswerReturn(unittest.TestCase):
    def testYes(self):
        with mockRawInput('yes'):
            self.assertEqual(answerReturn(), 'you entered yes')

    def testNo(self):
        with mockRawInput('no'):
            self.assertEqual(answerReturn(), 'you entered no')

Denke ich, gut beantwortet den ersten Teil von diesem. Zu dem zweiten Teil - Prüfung print. Ich fand das viel schwieriger - ich würde gerne hören, wenn jemand eine bessere Antwort.

Sowieso, die print - Anweisung kann nicht überschrieben werden, aber wenn Sie print() Funktionen statt (wie Sie sollte) und die from __future__ import print_function können Sie die folgenden verwenden:

class PromiseString(str):
    def set(self, newString):
        self.innerString = newString

    def __eq__(self, other):
        return self.innerString == other

@contextmanager
def getPrint():
    promise = PromiseString()
    original_print = __builtin__.print
    __builtin__.print = lambda message: promise.set(message)
    yield promise
    __builtin__.print = original_print

class TestAnswer(unittest.TestCase):
    def testYes(self):
        with mockRawInput('yes'), getPrint() as response:
            answer()
            self.assertEqual(response, 'you entered yes')

    def testNo(self):
        with mockRawInput('no'), getPrint() as response:
            answer()
            self.assertEqual(response, 'you entered no')

Das knifflige bit ist hier, dass Sie brauchen, um yield eine Antwort, bevor die with - block eingegeben wird. Aber Sie können nicht wissen, was die Antwort sein wird, bis die print() innerhalb der with - block aufgerufen wird. Dies wäre in Ordnung, wenn Saiten wurden verändert, aber Sie sind nicht. Anstatt also ein kleines Versprechen oder proxy-Klasse aus - PromiseString. Es macht nur zwei Dinge - lassen Sie eine Zeichenfolge (oder so was) eingestellt werden und lassen Sie uns wissen, wenn es gleich einer anderen Zeichenfolge. Ein PromiseString ist yielded und legen Sie dann den Wert, der normalerweise print innerhalb der with block.

Hoffentlich schätzen Sie alle diese Tricks, die ich geschrieben habe, da dauerte es rund 90 Minuten, um gemeinsam an diesem Abend. Getestet habe ich alle von diesem Kodex und überprüft alles funktioniert mit Python 2.7.

InformationsquelleAutor der Antwort ArtOfWarfare

Ich bin mit Python 3.4 und anpassen musste Antworten. Meine Lösung Faktoren die gemeinsamen code in die custom - runTest Methode und zeigt, wie Sie patch-beide input() und print(). Hier ist code, der ausgeführt wird:
import unittest
von io import StringIO
von unittest.mock-import-patch

def answer():
    ans = input('enter yes or no')
    if ans == 'yes':
        print('you entered yes')
    if ans == 'no':
        print('you entered no')


class MyTestCase(unittest.TestCase):
    def runTest(self, given_answer, expected_out):
        with patch('builtins.input', return_value=given_answer), patch('sys.stdout', new=StringIO()) as fake_out:
            answer()
            self.assertEqual(fake_out.getvalue().strip(), expected_out)

    def testNo(self):
        self.runTest('no', 'you entered no')

    def testYes(self):
        self.runTest('yes', 'you entered yes')

if __name__ == '__main__':
    unittest.main()

InformationsquelleAutor der Antwort tbc0

Einfach nur posten, was ich brauchte, mit python 3.6.3

Die input-Funktion wurde verwendet, die mehrfach in einer einzigen Funktion, die ich hatte zu prüfen, so dass eine änderung der return nicht funktioniert.
Ich musste auch die Verwendung der verschiedenen Eingänge jedes mal, wenn es verwendet wurde.

Hier ist eine kurze demo zeigt zwei Methoden auf, wie Sie diese erreichen

from unittest.mock import patch
from unittest import TestCase


def answer():
    ans = input('enter yes or no')
    result = ""
    if ans == 'yes':
        result += 'yes'
    if ans == 'no':
        result += 'no'
    ans2 = input('enter 1 or 2')
    if ans2 == '1':
        result += '1'
    if ans2 == '2':
        result += '2'
    return result


class TestInput(TestCase):

    @patch('builtins.input', side_effect=['yes', '1'])
    def test_answer_yes(self, mock):
        self.assertEqual(answer(), 'yes1')

    def test_answer_yes2(self):
        user_input = ['no', '2']
        with patch('builtins.input', side_effect=user_input):
            self.assertEqual(answer(), 'no2')

InformationsquelleAutor der Antwort BustahBoi