Je me demandais si Unittest ou Pytest suffirait, mais j'ai décidé de consulter le cadre de test de Tornado. J'ai trouvé qu'il serait utile de démarrer Tornado HTTP Server dans le script de test et de l'appeler Tornado Mock Server, ou de l'exécuter et de le tester, j'ai donc décidé de l'implémenter immédiatement. .. J'ai alors décidé de résumer l'exemple de code sous forme de mémorandum. Depuis que j'ai essayé la série 2.4 cette fois, les informations sont peut-être un peu anciennes, mais les bases ne devraient pas changer.
test_tornadoweb.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#Importer les modules requis
import tornado.testing
import tornado.web
import mock
import urllib
from tornado.httpclient import HTTPRequest
#Fonction d'assistance
def urlencode_request_params(**params):
return urllib.urlencode(
dict(
[k, v.encode("utf-8") if isinstance(v, unicode) else v]
for k, v in params.items()
)
)
def prepare_kwargs(**params):
kwargs = dict(
body=urlencode_request_params(**params),
)
return kwargs
#Gestionnaire d'échantillons
class ProfileHandler(tornado.web.RequestHandler):
"""Pour essayer get method
"""
def get(self):
user_id = self.get_argument("user_id")
if user_id != "tornadoweb":
raise tornado.web.HTTPError(404)
self.finish("ok")
class AccountHandler(tornado.web.RequestHandler):
"""tornado.web.Tests lors de l'utilisation de décorateurs authentifiés
Choses à faire
"""
@tornado.web.authenticated
def get(self):
self.finish("I'm " + self.current_user)
@tornado.web.authenticated
def post(self):
bio = self.get_argument("bio")
self.finish("{error:0, msg:{bio:%s}}" % bio)
class TestSample(tornado.testing.AsyncHTTPTestCase):
"""Hériter AsyncHTTPTestCase et démarrer le serveur HTTP
"""
def setUp(self):
"""Trouvez un port gratuit dans la super classe_Enregistré dans l'application
Démarrer Tornado avec le gestionnaire comme application
self.http_le client est préparé et lui-même.http_client.fetch()
Peut également être utilisé
"""
super(TestSample, self).setUp()
def get_httpserver_options(self):
"""Vous pouvez également spécifier des options lors du démarrage du serveur HTTP
"""
return {}
def get_app(self):
"""Définissez le routage du gestionnaire de l'application.
Si vous disposez de paramètres d'application, vous pouvez les spécifier ici.
"""
application_settings = dict()
return tornado.web.Application([
("/profile", ProfileHandler),
("/account", AccountHandler),
("/account/update", AccountHandler),
], **application_settings)
def test_httprequest_sample(self):
"""Vous pouvez également faire une demande directement en utilisant HTTP Request, donc un test d'essai
"""
kwargs = dict()
test_url = 'http://snapdish.co'
request = HTTPRequest(test_url, **kwargs)
self.http_client.fetch(request, self.stop, **kwargs)
response = self.wait()
self.assertEqual(response.code, 200)
def test_profile(self):
"""Testez si vous pouvez obtenir le profil normalement
"""
kwargs = dict(
user_id="tornadoweb"
)
path = "%s?%s" % ("/profile", urlencode_request_params(**kwargs))
response = self.fetch(path)
self.assertEqual(response.code, 200)
self.assertEqual(response.body, "ok")
def test_profile_404(self):
"""Teste si la demande de profil renvoie 404 si elle est incorrecte
"""
kwargs = dict(
user_id="tornadoweb?"
)
path = "%s?%s" % ("/profile", urlencode_request_params(**kwargs))
response = self.fetch(path)
self.assertEqual(response.code, 404)
def test_account(self):
"""Lorsqu'un décorateur authentifié est utilisé, utilisez une simulation
current_l'utilisateur doit être modifié"""
with mock.patch.object(AccountHandler, 'get_current_user') as m:
m.return_value = "tornadoweb"
path = "/account"
response = self.fetch(path)
self.assertEqual(response.code, 200)
self.assertEqual(response.body, "I'm tornadoweb")
def test_account_update(self):
"""Lorsqu'un décorateur authentifié est utilisé, utilisez une simulation
current_l'utilisateur doit être modifié"""
with mock.patch.object(AccountHandler, 'get_current_user') as m:
m.return_value = "tornadoweb"
bio = "tornadoweb bio"
params = dict(bio=bio)
response = self.fetch("/account/update",
method="POST",
follow_redirects=False,
body=urlencode_request_params(**params))
self.assertEqual(response.code, 200)
self.assertEqual(response.body, "{error:0, msg:{bio:%s}}" % bio)
setUp() Cela fonctionne en recherchant un port libre, en préparant http_client, en définissant un gestionnaire d'application et en démarrant Tornado HTTP Server. get_app() Il est implémenté du côté de la sous-classe et spécifie le gestionnaire que vous souhaitez tester et son chemin. Vous pouvez également configurer l'application ici. Spécifiez template_path, etc. fetch(path, **kwargs)
self.http_client.Auto dans un emballage de récupération.get_url(path)Je fais. soi.get_url(path)Utilisera le chemin passé en argument pour générer une URL vers le serveur HTTPS démarré dans ce test et exécuter la requête. Lorsque vous souhaitez faire une demande compliquée, vous.http_client.fetch(request, self.stop, **kwargs)Gérez les demandes directement à l'aide de. À ce moment-là, la réponse est soi.wait()Pour utiliser.
## Les décorateurs tornado.web.authenticated ne sont pas pris en charge
Il semble qu'il n'y ait pas d'autre choix que de tricher en utilisant des biscuits simulés ou des cookies. Vous pouvez également utiliser HTTPRequest, vous pouvez donc faire différentes choses en fonction de l'implémentation.
## Exécution en ligne de commande
Spécifiez le nom du module (nom de fichier) comme suit et exécutez.
```bash
$ python -m tornado.test.runtests test_tornadoweb
https://github.com/tornadoweb/tornado/tree/master/tornado/test http://www.tornadoweb.org/en/branch2.4/testing.html
Recommended Posts