J'ai expliqué le tutoriel de Django quatre fois, Dernière fois a terminé toute la demande.
La partie 5 expliquera l'introduction des tests automatisés.
Un test est un programme simple qui vérifie le comportement de votre code.
Les tests s'exécutent à un niveau différent de celui du code dans d'autres applications. Certains tests peuvent être effectués sur de petites fonctionnalités (une méthode dans un modèle particulier renvoie-t-elle la valeur attendue?), Et un autre test est effectué sur le comportement de l'ensemble du logiciel. (La séquence des entrées de l'utilisateur sur le site produit-elle les résultats attendus?).
Ce qui distingue les tests automatisés, c'est que le travail de test est effectué par le système. Une fois que vous avez créé un ensemble de test, chaque fois que vous apportez des modifications à votre application, vous pouvez voir si votre code fonctionne comme prévu. Le test manuel ne prend pas longtemps.
Le fait d'avoir le code de test vous donne la tranquillité d'esprit que les gens peuvent le voir sur GitHub. (Sinon, ce projet ira bien.)
Si vous exécutez le code pour ce test et renvoyez Suceess, quels que soient les correctifs que vous avez mis en place, il est sans bogue et prêt à être lancé.
L'écriture de code de test est plus qu'un simple test Il rassure le lecteur du code et garantit qu'une série de tests peut être garantie lorsqu'elle est développée par plusieurs personnes.
Écrivez selon le principe du «test piloté»! Sans oublier, il est impératif de se préparer enfin au test.
Django recommande également d'écrire du code de test, Il existe des modules qui facilitent la création de tests.
Je voudrais exécuter le code de test avec un exemple.
En fait, les applications de vote que j'ai créées jusqu'à présent ont un petit bogue.
polls/models.py
from django.db import models
from django.utils.encoding import python_2_unicode_compatible
from django.utils import timezone
import datetime
# Create your models here.
@python_2_unicode_compatible
class Question(models.Model):
question_text = models.CharField(max_length=200)
pub_date = models.DateTimeField('date published')
def __str__(self):
return self.question_text
#Cette méthode
def was_published_recently(self):
return self.pub_date >= timezone.now() - datetime.timedelta(days=1)
@python_2_unicode_compatible
class Choice(models.Model):
question = models.ForeignKey(Question, on_delete=models.CASCADE)
choice_text = models.CharField(max_length=200)
votes = models.IntegerField(default=0)
def __str__(self):
return self.choice_text
La méthode `` was_published_recently '' ci-dessus est une méthode qui renvoie True si la question a été créée après hier.
C'est correct, mais cette méthode renvoie True même dans les dates futures. (Il n'y a pas de tel vote.)
Vérifions en fait l'opération avec la commande shell fournie par Django.
Exécutez la commande suivante dans le terminal.
>>> import datetime
>>> from django.utils import timezone
>>> from polls.models import Question
>>> # create a Question instance with pub_date 30 days in the future
>>> future_question = Question(pub_date=timezone.now() + datetime.timedelta(days=30))
>>> # was it published recently?
>>> future_question.was_published_recently()
True
Comme prévu, True est de retour. Ce résultat est incorrect car la date future n'est pas "récente".
Ce serait pratique si vous pouviez laisser ce que vous avez fait ci-dessus dans votre projet en tant que code de test et le tester à tout moment. (Vous savez également ce que la méthode veut faire.)
Créez en fait le code de test.
Tout d'abord, la structure du répertoire où le code de test est placé, Créez-le avec le nom tests.py sous le répertoire polls.
polls/tests.py
from django.test import TestCase
import datetime
from django.utils import timezone
from .models import Question
# Create your tests here.
class QuestionMethodTest(TestCase):
def test_was_published_recently_with_future_question(self):
time = timezone.now() + datetime.timedelta(days=30)
future_question = Question(pub_date=time)
self.assertIs(future_question.was_published_recently(), False)
Tout d'abord, nous créons une sous-classe qui hérite de django.test.TestCase et créons une instance de Question avec un pub_date d'une date future. Ensuite, je vérifie la sortie de was_published_recently (). Cela devrait être faux.
C'est un code très intuitif, et cela semble être Python / Django.
Exécutez la commande suivante dans le terminal pour démarrer le test automatisé.
$ python manage.py test polls
Ensuite, le résultat d'exécution suivant sera obtenu.
Creating test database for alias 'default'...
F
======================================================================
FAIL: test_was_published_recently_with_future_question (polls.tests.QuestionMethodTests)
----------------------------------------------------------------------
Traceback (most recent call last):
File "/path/to/mysite/polls/tests.py", line 16, in test_was_published_recently_with_future_question
self.assertIs(future_question.was_published_recently(), False)
AssertionError: True is not False
----------------------------------------------------------------------
Ran 1 test in 0.001s
FAILED (failures=1)
Destroying test database for alias 'default'...
Dans ce qui précède, les opérations suivantes sont effectuées.
--python manage.py test polls recherche des tests dans les applications de sondage --Découvrez une sous-classe de la classe django.test.TestCase --Créer une base de données spéciale pour les tests
Corrigeons en fait Question.was_published_recently.
polls/models.py
from django.db import models
from django.utils.encoding import python_2_unicode_compatible
from django.utils import timezone
import datetime
# Create your models here.
@python_2_unicode_compatible
class Question(models.Model):
question_text = models.CharField(max_length=200)
pub_date = models.DateTimeField('date published')
def __str__(self):
return self.question_text
#Méthode modifiée
def was_published_recently(self):
now = timezone.now()
return now - datetime.timedelta(days=1) <= self.pub_date <= now
@python_2_unicode_compatible
class Choice(models.Model):
question = models.ForeignKey(Question, on_delete=models.CASCADE)
choice_text = models.CharField(max_length=200)
votes = models.IntegerField(default=0)
def __str__(self):
return self.choice_text
Après avoir effectué la correction, exécutez à nouveau la commande de test.
Creating test database for alias 'default'....
----------------------------------------------------------------------
Ran 1 test in 0.001s
OK
Destroying test database for alias 'default'...
Comme mentionné ci-dessus, le test s'est terminé avec succès et OK s'affiche.
Ce test automatisé s'est concentré sur le test du modèle, mais il existe bien sûr également des vues et d'autres tests.
J'ai brièvement présenté l'ensemble du test et seulement le début de l'écriture du code de test.
J'espère pouvoir vous montrer comment écrire un autre code de test à un autre moment.
La prochaine fois, dans le dernier chapitre, j'expliquerai comment Django gère les fichiers statiques.
Recommended Posts