En python, comment faire un test unitaire sur une fonction sans valeur de retour?

Je suis un pythoner. Lors de ces jours je vais me faire un plus complet de l'unité de test sur certains module de base dans mon projet.
Depuis que nous avons toujours à faire de test de l'unité avec des méthodes assertEqual', 'assertTrue" et ainsi de suite, ces méthodes nécessitent toutes une valeur de retour de la fonction testée, je me demandais comment faire un simple test de l'unité sur une fonction sans valeur de retour.

Je voudrais montrer un petit exemple ici, comment tester la fonction def foo(auto, msg) dans HelloTest?

class HelloTest(object):
    def foo(self, msg):
        MSG = msg.upper()
        self.bar(MSG)

    def bar(self, MSG):
        print MSG

source d'informationauteur Yarkee

python unit-testing

5

Dans ce cas particulier, je serait se moquer d'impression, puis ensuite utiliser la fantaisie dans mon affirmation.

En Python, vous allez utiliser la Se moquer de package en dérision.
9

Comme une autre réponse mentionné précédemment, vous pouvez utiliser le Python se moquer de la bibliothèque pour faire des assertions sur des appels à des fonctions/méthodes
```
from mock import patch
from my_module import HelloTest
import unittest

class TestFoo(unittest.TestCase):

    @patch('hello.HelloTest.bar')
    def test_foo_case(self, mock_bar):

        ht = HelloTest()

        ht.foo("some string")
        self.assertEqual(ob.msg, "SOME STRING")
        self.assertTrue(mock_bar.called)
```
Ce patch le bar méthode sur HelloTest et le remplace par un objet fantaisie qui enregistre les appels contre elle.

Moqueur est un peu un trou de lapin. Seulement le faire quand vous devez absolument car elle permet de faire vos tests fragile. Vous ne serez jamais à l'avis d'une API changer pour se moquaient de l'objet par exemple.
6

Je n'arrive pas à comprendre pourquoi tout le monde veut vérifier que foo appels bar.

Foo a certaines fonctionnalités et cette fonctionnalité doit être testé. Si toto est à l'aide de la barre pour ce faire, ne devrait pas être de mon inquiétude.

Le résultat souhaité est que, après foo(msg) est appelé, c'est que msg.upper() est envoyé vers la sortie standard.

Vous pouvez rediriger stdout vers un tampon de chaîne et de vérifier si le contenu de ce tampon de chaîne correspond à ce que vous attendez.

Exemple:
```
import sys
import unittest
from io import TextIOWrapper, BytesIO

class TestScript(unittest.TestCase):
    def setUp(self):
        self._old_stdout = sys.stdout
        sys.stdout = TextIOWrapper(BytesIO(), sys.stdout.encoding)

    def _output(self):
        self._stdout.seek(0)
        return self._stdout.read()

    def test_foo(self):
        hello_test = HelloTest()
        hello_test.foo("blub")
        self.assertEqual(self._output(), "BLUB")

    def tearDown(self):
        sys.stdout = self._old_stdout
        self._stdout.close()
```
Vous pouvez le faire aussi pour l'entrée standard (et d'écrire sur stdin pour se moquer de certains intrants) et vous pouvez sous-classe TestIOWrapper si vous avez besoin quelque chose de spécial à faire, comme en permettant à des non-unicode texte qui sera envoyé aux sys.stdout sans l'aide de sys.stdout.buffer (Python 2 vs Python 3).
Il est un exemple pour que, dans cette SORTE de réponse.
Lorsque vous (encore) l'utilisation de Python 2, puis à l'aide de StringIO peut-être mieux que d'utiliser le io module.

votre code peut être que donnée ci-dessous qui n'a même tâche que ci-dessus:

class HelloTest(object):

    def foo(self, msg):
        self.msg = msg.upper()
        self.bar()

    def bar(self):
        print self.msg

Unité de test est :

from hello import HelloTest
import unittest

class TestFoo(unittest.TestCase):
    def test_foo_case(self):
        msg = "test"
        ob = HelloTest()
        ob.foo(msg)
        expected = "TEST"
        self.assertEqual(ob.msg, expected)

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

2

En Python 3, vous pouvez dire print imprimer:

d'impression(*objets, sep=' ', end='\n', fichier=sys.stdout, flush=False)

Donc ajouter un argument facultatif:
```
def bar(self, MSG, file=sys.stdout):
    print(MSG, file=file)
```
Dans des conditions normales d'utilisation, il permet d'imprimer sur la sortie standard, mais pour les tests unitaires, vous pouvez passer votre propre fichier.

En Python 2 c'est un peu messier, mais vous pouvez rediriger stdout vers un StringIO tampon:
```
import StringIO
import sys

out = StringIO.StringIO()
sys.stdout = out

# run unit tests

sys.stdout = sys.__stdout__

# check the contents of `out`
```

Grâce à @Jordan introduction, je code ce et pense que c'est une pratique de test unitaire pour HelloTest.foo

from mock import Mock
import unittest


class HelloTestTestCase(unittest.TestCase):
    def setUp(self):
        self.hello_test = HelloTest()

    def tearDown(self):
        pass

    def test_foo(self):
        msg = 'hello'
        expected_bar_arg = 'HELLO'
        self.hello_test.bar = Mock()

        self.hello_test.foo(msg)
        self.hello_test.bar.assert_called_once_with(expected_bar_arg)


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

Vous devez vous connecter pour publier un commentaire.