TOC

Test à Django (Partie 2) - Modèle Mommy vs Django Testing Rencontres

Test à Django (Partie 2) - Modèle Mommy vs Django Testing Rencontres

Dans les dernierspost, je vous ai présenté les tests dans Django et nous avons examiné les meilleures pratiques ainsi que quelques exemples. Cette fois, je vais vous montrer un exemple un peu plus compliqué et vous présenterModel Mommy pour créer des exemples de données.

Pourquoi devriez-vous vous en soucier?

Dans le dernier message, j'ai dit que «https://github.com/rbarrois/factory_boy[factory_boy],model_mommy etmock sont tous utilisés à la place des appareils ou de l'ORM pour le remplissage données nécessaires pour les tests. Les appareils et l'ORM peuvent être lents et doivent être mis à jour chaque fois que votre modèle change. »

Pour résumer, les appareils de test Django sont problématiques car ils:

  • doit être mis à jour chaque fois que votre modèle / schéma change,

  • sont vraiment, vraiment lents; et

  • parfois, des données codées en dur peuvent entraîner l'échec de vos tests à l'avenir.

Ainsi, en utilisant Model Mommy, vous pouvez créer des appareils qui se chargent plus rapidement et sont beaucoup plus faciles à entretenir au fil du temps.

Django Testing Fixtures

Commençons par regarder notre exemple de test du modèle dans le dernier article: 

class WhateverTest(TestCase):

    def create_whatever(self, title="only a test", body="yes, this is only a test"):
        return Whatever.objects.create(
            title=title, body=body, created_at=timezone.now())

    def test_whatever_creation(self):
        w = self.create_whatever()
        self.assertTrue(isinstance(w, Whatever))
        self.assertEqual(w.__unicode__(), w.title)

Ici, nous avons simplement créé un objetWhatever() et affirmé que le titre créé correspondait au titre attendu.

Si vous avez téléchargé le projet à partir desrepo, lancez le serveur et exécutez les tests: 

$ coverage run manage.py test whatever -v 2

Vous verrez que les tests ci-dessus réussissent: 

test_whatever_creation (whatever.tests.WhateverTest) ... ok

Maintenant, au lieu d'avoir à créer une nouvelle instance, avec chaque attribut, à chaque fois (ennuyeux!), Nous pouvons utiliser Model Mommy pour rationaliser le processus.

Modèle maman

Installer: 

$ pip install model_mommy

Rappelez-vous à quoi ressemble notre modèle? 

class Whatever(models.Model):
    title = models.CharField(max_length=200)
    body = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __unicode__(self):
        return self.title

Nous pouvons maintenant réécrire le test ci-dessus d'une manière beaucoup plus simple: 

from model_mommy import mommy

class WhateverTestMommy(TestCase):

    def test_whatever_creation_mommy(self):
        what = mommy.make(Whatever)
        self.assertTrue(isinstance(what, Whatever))
        self.assertEqual(what.__unicode__(), what.title)

Exécuter. Cela a-t-il réussi?

C'était facile? Pas besoin de passer d'arguments.

Nouveau modèle

Regardons un exemple un peu plus compliqué.

Installer

Créez une nouvelle application: 

$ python manage.py startapp whatevs

Ajoutez l'application auxInstalled_Apps dans le fichiersettings.py

Créez le modèle: 

from django.db import models
from django.contrib.auth.models import User
from django.contrib import admin

class Forum(models.Model):
    title = models.CharField(max_length=100)

    def __unicode__(self):
        return self.title

class Post(models.Model):
    title = models.CharField(max_length=100)
    created = models.DateTimeField(auto_now_add=True)
    creator = models.ForeignKey(User, blank=True, null=True)
    forum = models.ForeignKey(Forum)
    body = models.TextField(max_length=10000)

    def __unicode__(self):
        return unicode(self.creator) + " - " + self.title

Synchronisez la base de données.

À quoi ressemble notre rapport de couverture?

Model Mommy test coverage

Test

Ajoutez les tests: 

from model_mommy import mommy
from django.test import TestCase
from whatevs.models import Forum, Thread

class WhateverTestMommy(TestCase):

    def test_forum_creation_mommy(self):
        new_forum = mommy.make('whatevs.Forum')
        new_thread = mommy.make('whatevs.Thread')
        self.assertTrue(isinstance(new_forum, Forum))
        self.assertTrue(isinstance(new_thread, Thread))
        self.assertEqual(new_forum.__unicode__(), new_forum.title)
        self.assertEqual(
            new_thread.__unicode__(),
            (str(new_thread.forum) + " - " + str(new_thread.title)))

Relancez vos tests (qui devraient réussir), puis créez le rapport de couverture: 

$ coverage run manage.py test whatevs -v 2
$ coverage html

Bien?

Voulez-vous essayer d'exécuter les tests ci-dessus en utilisant les fixturesJSON pour voir comment configurer les tests en utilisant les correctifs de test Django?

Je ne sais pas ce que nous aurons en magasin pour le prochain didacticiel, alors faites-moi savoir ce que vous aimeriez voir. Saisissez le codehere. N'oubliez pas de commenter ci-dessous si vous avez des questions. À votre santé!

Related