Comment charger des luminaires qu'une seule fois dans django tests unitaires ?

Dans les tests unitaires j'ai besoin de charger les montages, comme ci-dessous:

   class TestQuestionBankViews(TestCase):

        # Load fixtures
        fixtures = ['qbank']

        def setUp(self):                           
            login = self.client.login(email="[email protected]",password="welcome")        


        def test_starting_an_exam_view(self):               
            candidate = Candidate.objects.get(email="[email protected]")
            .......etc


        def test_review_view(self):
            self.assertTrue(True)            
            .........

       def test_review_view2(self):
            self.assertTrue(True)
            .........

Problème:

Ces appareils sont en cours de chargement pour chaque test, c'est à dire avant test_review_view, test_review_view2, etc., comme Django bouffées de chaleur de la base de données après chaque test.

Ce comportement est à l'origine de tests pour prendre une longue période de temps.

Comment puis-je éviter cette redondance gabarit de chargement?

Est-il un moyen de charger des appareils dans setUp et de les éliminer lors de la classe de test est terminée, au lieu de rinçage entre chaque test?

  • oh......... je pense que je peux résoudre ce problème en utilisant intial_data luminaire, héritage de la "unittest.Cas de test" au lieu de "tester.Cas de test"? Toutes les autres pensées?
InformationsquelleAutor Rama Vadakattu | 2009-06-11
  1. 20

    À l'aide de django-nez et un peu de code, vous pouvez faire exactement ce que vous avez demandé. Avec django-nez, vous pouvez avoir par colis, par module et par classe d'installation et de démontage des fonctions. Qui vous permet de charger vos appareils dans l'un des plus des fonctions de configuration et de désactiver le django.test.Cas de test de réinitialisation de ces accessoires, entre les tests.

    Voici un exemple de fichier de test:

    from django.test import TestCase
from django.core import management

    def setup():
        management.call_command('loaddata', 'MyFixture.json', verbosity=0)

    def teardown():
        management.call_command('flush', verbosity=0, interactive=False)

    class MyTestCase(TestCase):

        def _fixture_setup(self):
            pass

        def test_something(self):
            self.assertEqual(1, 1)

    Avis que l'installation et le démontage sont à l'extérieur de la classe. Le programme d'installation va être exécuté avant que toutes les classes de test dans ce fichier, et le démontage sera exécuté après toutes les classes de test.

    À l'intérieur de la classe, vous remarquerez que les def _fixture_setup(auto) méthode. Ceci remplace la fonction réinitialise la base de données entre chaque test.

    Gardez à l'esprit que si vos tests écrire quoi que ce soit à la base de données, ce qui pourrait invalider votre tests. Si tous les autres tests qui ont besoin de luminaires reloaded pour chaque essai doit être mis dans un autre fichier de test.

    • +1 pour une solution fonctionnelle qui laisse de la place pour une approche différente de celle de l'aide initial_data.json/yaml. (J'utilise une gestion personnalisée de commande et un script qui appelle l'ORM de Django, pour créer mes données initiales. Cela me permet d'intégrer parfaitement.) Ce doit être la accepté de répondre, il m'a beaucoup aidée!
    • Excellente solution! Une chose que j'ai découvert qui est assez utile. Si vous ne mettez pas dans le def _fixture_setup(auto) la méthode, et de permettre à la Django cas de test à abattre, comme d'habitude, toutes les modifications de base de données dans un délai d'un cas de test n'aura pas d'effet à la prochaine. C'est parce que dès le début d'un cas de test, une transaction de base de données est démarrée, et pendant le démontage de la phase du cas de test va effectuer une db de restauration pour rétablir l'état de la base de données. Donc, en ignorant la def _fixture_setup() vous donnera le paris des deux mondes!
    InformationsquelleAutor mhost
  2. 13

    Ou de l'utilisation setUpModule:

    def setUpModule():
    print 'Module setup...'

def tearDownModule():
    print 'Module teardown...'

class Test(unittest.TestCase):
    def setUp(self):
       print 'Class setup...'

    def tearDown(self):
       print 'Class teardown...'

    def test_one(self):
        print 'One'

    def test_two(self):
        print 'Two'

    imprime:

    Creating test database for alias 'default'...
Module setup...
Class setup...
One
Class teardown...
Class setup...
Two
Class teardown...
Module teardown...
    • Cela ne fonctionne que si tous les tests sur le module utilise le même appareil. En d'autres termes, il vous oblige à mettre des tests sur un module donné par ce luminaire ils utilisent, à la place de ce qu'ils testent.
    InformationsquelleAutor Tom Wainwright
  3. 7

    Si vous ne vous sentez pas comme l'installation d'un nouveau paquet juste pour cela, vous pouvez combiner Tom Wainwright de la solution et mhost de la solution.

    Dans votre testfile, ajouter ces fonctions en dehors de toutes les classes:

    from django.core.management import call_command

def setUpModule():
    call_command(
        'loaddata', 
        'path_to_fixture.json',
        verbosity=0
    )

def tearDownModule():
    call_command('flush', interactive=False, verbosity=0)

    Si vous ne voulez pas avoir ces appareils chargés dans la base de données pour tous les cas de test, diviser le test en plusieurs fichiers par la création d'un nouveau répertoire dans le répertoire de l'application appelée tests, ajouter un vide __init__.py fichier de dire à Python que c'est un package, et d'ajouter vos fichiers de test avec les noms de fichiers qui commencent par test, depuis le coureur va chercher les fichiers correspondant au motif test*.py

    • Remarque, si l'utilisation de cette approche, vous devez remplacer les deux _fixture_setup et _fixture_teardown ainsi que les accessoires dont vous avez chargé dans setupmodule ne sont pas bourrés par le montage, démontage.
    • A noter également, cette approche ne permet pas de réinitialiser l'auto-incrémentation des clés primaires/id; donc vous ne devriez pas compter sur l'Id de commencer (ou recommencer) à votre test.
    InformationsquelleAutor kerryz
  4. 6

    Pour ce que ça vaut, et depuis il n'y a pas de réponse, Django 1.8 maintenant fournit cette fonctionnalité de la boîte - à condition que vous êtes en utilisant une base de données client qui prend en charge les transactions.

    Il ajoute également le cas de test.setUpTestData() la méthode la création manuelle de données de test une fois par cas de test de la classe.

    Voir le Django de 1,8 notes de version.

    InformationsquelleAutor oogles
  5. 3

    J'ai couru dans le même problème. En général, il n'y a pas une très bonne façon de le faire à l'aide de django reinhardt, de test runner. Vous pourriez être intéressé par ce fil

    Avec cela étant dit, si tous les cas de tests d'utiliser le même montage, et ils n'ont pas de modifier les données d'une façon quelconque, à l'aide de initial_data serait de travailler.

    • Merci pour le pointeur,& Oui ( je n'ai pas pensé à cela plus tôt), nous pouvons utiliser intial_data que si tous les cas de test ne pas modifier la base de données
    • j'ai décidé d'utiliser unittest.Cas de test avec intial_data . Aucune idée sur la façon d'obtenir toutes les commodités fournies par django.test.Cas de test?
    InformationsquelleAutor jamesls
  6. 1

    J'ai eu un problème similaire une fois et fini par écrire mon propre test runner. Dans mon cas, initial_data n'était pas le bon endroit comme initial_data serait chargé au cours de syncdb, quelque chose que je ne voulais pas. J'ai remplacé setup_ et teardown_test_environment méthodes pour charger mon dispositif personnalisé avant de la suite de test a été exécuté et l'enlever une fois fait.

    InformationsquelleAutor Manoj Govindan
  7. 0

    django-nez offre une solution toute faite à ce problème: il suffit de la sous-classe django_nose.FastFixtureTestCase.

    En outre, django-nez prend en charge luminaire regroupement, ce qui peut accélérer l'exécution de vos tests encore plus que par le chargement de chaque ensemble unique de luminaires une fois par essai. Après avoir sous-classé FastFixtureTestCase le cas échéant, exécuter la django-nez lanceur de test à l'aide de la --with-fixture-bundling option.

    Voir django-nez sur pypi pour plus d'informations.

    InformationsquelleAutor Joel Crocker