tl.testing

tl.testing fournit divers utilitaires qui peuvent être utilisés lors de l'écriture des tests & nbsp;. Il est compatible avec les versions 2.6 et Python 2.7.
Les bacs à sable de répertoires et de fichiers
Lors du test de code qui modifie les répertoires et fichiers, il est utile d'être capable de créer et d'inspecter un arbre de répertoires et de fichiers échantillon facilement. Le module tl.testing.fs fournit un soutien pour la création d'un arbre à partir d'une description textuelle, l'inscrivant dans le même format et nettoyer après lui-même.
Dans un test de doc, ces installations pourraient servir de ce genre pour créer et lister un répertoire, un fichier et un lien symbolique:
>>> de tl.testing.fs new_sandbox d'importation, ls
>>> New_sandbox ("" ​​"
... D foo
... F foo / bar asdf
... L baz -> foo / bar
... "" ")
>>> (ls)
l baz -> foo / bar
d foo
f foo / bar asdf
Voir le fichier fs.txt trouvé avec le code source pour plus de conseils, y compris comment mettre en place et de démolir des tests utilisant des bacs à sable du système de fichiers.
Installation des scripts appelables
Certaines fonctionnalités on peut vouloir tester rend l'utilisation de programmes externes, comme un téléavertisseur ou un éditeur de texte. Le module de tl.testing.script fournit des utilitaires qui installent simples simulacres son exécution dans les endroits où le code à tester va les trouver. Ils prennent une chaîne de code Python et de créer un script d'emballage qui définit le chemin de Python pour correspondre à celle du test et exécute le code.
Ce est comment un tel script maquette pourrait être utilisé dans un essai de doc:
>>> De l'importation tl.testing.script installer
>>> Script_path = installer ("print" Un simple script. ")
>>> Print ouverte (script_path) .read ()
#! ...

import sys
sys.path [:] = [...]

print 'Un simple script. "
>>> Sous-processus d'importation
>>> Sub = subprocess.Popen (script_path, coquille = True, stdout = subprocess.PIPE)
>>> Stdout, stderr = sub.communicate ()
>>> Print stdout
Un simple script.
Voir le fichier script.txt trouvé avec le code source pour plus de possibilités comment installer et son accès ainsi que des simulacres Comment abattre les tests utilisant des scripts de simulation.
Doc-tester le contenu graphique des surfaces de cairo
Se il est simple pour comparer le contenu de deux surfaces de Caire en code Python, la manipulation graphiques est au-delà des tests de doc. Toutefois, le package manuel peut être utilisé pour extraire des cas plus généraux de test à partir d'un document texte, tout en permettant de les mélanger avec des tests de doc d'une manière naturelle.
Le module de tl.testing.cairo fournit une usine de suite de tests qui utilise manuel pour exécuter les tests graphiques formulées comme des figures restructuré-texte. La légende d'un tel chiffre est censé être une expression Python littérale dont la valeur est une surface de cairo, et son image est utilisée comme l'espérance de test.
Ce est ainsi une surface pourrait être comparé à une image attendue dans un test de doc:
>>> Cairo d'importation
>>> From pkg_resources de resource_filename d'importation
>>> Image = resource_filename ('tl.testing »,« testimages / correct.png')
.. Figure :: tl / tests / testimages / correct.png
& Nbsp; `` cairo.ImageSurface.create_from_png (image) ``
Voir le fichier cairo.txt trouvé avec le code source pour obtenir des conseils et de la documentation de la sortie de test possible plus loin.
Travailler avec des fils dans le code de test
La classe TestCase norme ne recueille pas les erreurs et les échecs qui se sont produits dans d'autres discussions que le principal. Le module de tl.testing.thread fournit des classes de fil et une classe de ThreadAwareTestCase pour permettre juste que, ainsi que d'autres commodités pour les essais qui traitent avec des fils: prévenir les exceptions non gérées attendus dans les discussions d'être imprimé avec la sortie de test, les discussions ayant déclaré laissés par un test, exécuter du code dans un thread démon, de rejoindre les discussions et en comptant les discussions ouvertes pendant le temps d'exécution de l'épreuve:
>>> Temps d'importation
>>> Tl.testing.thread d'importation
>>> Classe SampleTest (tl.testing.thread.ThreadAwareTestCase):
...
... Def test_error_in_thread_should_be_reported (auto):
... Avec tl.testing.thread.ThreadJoiner (1):
... Self.run_in_thread (lambda: 1/0)
...
... Def test_active_count_should_count_only_new_threads (self):
... Avec tl.testing.thread.ThreadJoiner (1):
... Self.run_in_thread (lambda: time.sleep (0,1))
... Self.assertEqual (1, self.active_count ())
Self.assertEqual ... (0, self.active_count ())
>>> Unittest d'importation
>>> Terme (unittest.makeSuite (SampleTest))
================================================== ====================
Erreur: test_error_in_thread_should_be_reported (__builtin __ SampleTest.)
-------------------------------------------------- --------------------
Retraçage (appel plus récente en dernier):
& Nbsp; ...
ZeroDivisionError: division entière par zéro ou modulo
-------------------------------------------------- --------------------
Ran deux tests N.NNNs
PAS (erreurs = 1)
Voir le fichier thread.txt trouvé avec le code source pour plus de détails de la classe ThreadAwareTestCase.
La construction des suites de tests qui utilisent manuel
Comme manuel fournit des fonctionnalités puissantes en plus doctests standards, des suites de tests Manuel sont mis en place de façon légèrement différente de celles standard. Le module tl.testing.doctest implémente une usine de DocFileSuite qui peut être utilisé comme une norme, mais crée une suite de tests utilisant manuel et permet une configuration supplémentaire liée à manuel, parmi eux la capacité d'interpréter les notes qui servent à être fait en utilisant l'obsolète zope.testing.doctest:
>>> Sample_txt = write ('sample.txt', "" "
... [#footnote] _
... >>> X
1 ...
...
... .. [#footnote]
... >>> X = 1
... "" ")
>>> From tl.testing.doctest DocFileSuite d'importation
>>> RUN (DocFileSuite (sample_txt, notes = true))
-------------------------------------------------- --------------------
Ran 1 essai dans N.NNNs
OK
>>> Sample_txt = write ('sample.txt', "" "
... .. Code-block :: python
X = 1 ...
...
... >>> X
1 ...
... "" ")
>>> Manuel.codeblock d'importation
>>> Terme (DocFileSuite (sample_txt, manuel = manuel.codeblock.Manuel ()))
-------------------------------------------------- --------------------
Ran 1 essai dans N.NNNs
OK

Exigences :

• Python