Quelle (s) approche (s) avez-vous utilisée pour les tests unitaires Python légers sur App Engine?

Question

Je suis sur le point de s'embarquer sur quelques grands Python Application basée sur le Moteur de projets, et je pense que je devrais vérifier avec un Débordement de Pile de la "sagesse des foules", avant d'engager un test unitaire de la stratégie. J'ai une unité existante cadre de tests (basé sur unittest personnalisé avec les coureurs et les extensions) que je veux utiliser, donc tout ce que les "poids lourds"/"intrusif" comme le nez, webtest, ou gaeunit ne semble pas approprié. L'essentiel des tests unitaires dans ma vision du monde sont extrêmement légers et rapides, ceux qui s'exécutent en un temps très court, afin que je puisse continuer à courir encore et tout le temps sans casser mon rythme de développement (par exemple, pour un autre projet, je reçois 97% ou si la couverture d'une 20K lignes du projet avec plusieurs dizaines de super-tests rapides qui prennent 5 à 7 secondes, le temps écoulé, pour un type d'exécuter, dans l'ensemble (c'est ce que je considère comme un décent suite de petites, unité fast-tests). Je vais avoir plus riches/plus lourd tests bien sûr, tout le chemin à des tests d'intégration avec le sélénium ou le moulin à vent, c'est pas ce que je veux parler;-) -- mon attention dans cette question (et à la plupart de mes efforts de développement;-) est sur le petit appareil léger-les tests à la légère et super-rapide de la couverture de mon code, et non pas sur les plus profondes.

Donc, je pense que ce dont j'ai besoin est essentiellement un ensemble de petites, très léger simulations de différents App Engine sous-systèmes -- banque de données, memcache, requête/réponse des objets et des appels à la webapp gestionnaires, l'utilisateur de la manipulation, de messagerie, &c, à peu près dans cet ordre de priorité. Je n'ai pas trouvé exactement ce que je recherche, il me semble donc que je devrait s'appuyer soit sur le mox, comme je l'ai fait souvent dans le passé, ce qui signifie fondamentalement se moquant de chaque sous-système utilisé dans un test donné, et la configuration de toutes les attentes &c (solide, mais beaucoup de travail à chaque fois, et très sensible à la testé-code interne, c'est à dire très "boîte blanche", y), ou rouler ma propre simulation de chaque sous-système (et de faire des assertions sur la simulation de sous-systèmes " les états dans le cadre des tests unitaires). Ces derniers semble possible, compte tenu de GAE de Python côté fort "stubs" l'architecture... mais je ne peux pas croire que j'ai besoin de renouveler mon propre, c'est à dire, que personne n'est déjà écrit, simple d'esprit simulateurs!-) E. g., de la banque de données, il ressemble à ce que j'ai besoin est plus ou moins la "banque de données sur le fichier" stub qui est déjà partie du kit de développement logiciel, en plus d'une façon de marquer en lecture seule et facile à utiliser des accesseurs pour les assertions à propos de la banque de données de l'état; et ainsi de suite, de sous par sous-système, chacun semble avoir besoin d'une "juste un peu plus" que ce qui est déjà dans le SDK, "perché au sommet" des "stubs" de l'architecture.

Donc, avant de plonger et de passer un jour ou deux de précieux temps de développement "rolling mon propre" simulations de GAE sous-systèmes pour l'unité des fins de test, j'ai pensé que j'avais un double contrôle de la foule et de voir ce qui y ' all pense à cela... ou, s'il y a déjà quelques open source existante ensemble de ces simulateurs que je peux simplement réutiliser (ou peu tweak!-), et que j'ai juste manqué de place dans ma recherche!-)

Edit: pour préciser, si je fais rouler ma part, je ne plan à effet de levier le SDK fourni par les talons lorsque c'est possible; mais par exemple il n'y a pas de stub pour une banque de données qui obtient d'abord lire dans un fichier, mais alors pas enregistré à la fin, donc j'ai besoin de sous-classe et de modifier l'existant (qui d'ailleurs n'offre pas particulièrement commode de façons de faire, affirme sur son état, de même pour le service de messagerie stub, etc). C'est ce que je veux dire par "rolling mon propre" - pas "de réécriture à partir de zéro"!-)

Edit: "pourquoi ne pas GAEUnit" -- GAEUnit est de nice, pour son propre cas, mais l'exécution dev_appserver et voir les résultats dans mon navigateur (ou même via urllib.urlopen) n'est certainement pas ce que je suis après -- je veux utiliser entièrement automatique de l'installation, adaptés pour fonctionner à l'intérieur d'un test-l'exécution d'un cadre qui est basé sur l'extension de unittest, et non "HTTP" dans la voie (dit-cadre définit un "rapide" test comme celui qui, parmi d'autres chose n'est pas de sockets et un minimum d'e/S de disque -- nous simuler ou de se moquer de ces -- via gaeunit je ne pouvait pas faire mieux que la "moyenne" des tests) + pas de moyen pratique pour préremplir le magasin de données pour chaque test (et pas OO de la structure pour aider à personnaliser les choses).

Answer 1

Vous n'avez pas besoin d'écrire vos propres stubs, le SDK les inclut, car ils servent à émuler les API de production. Tous ne conviennent pas à une utilisation dans des tests unitaires, mais la plupart le sont. Consultez ce code pour obtenir un exemple du code d'installation / de démontage nécessaire pour utiliser les stubs intégrés.

Answer 2

NoseGAE est un plugin de type nez qui prend en charge unittests en configurant automatiquement l'environnement de développement et un magasin de données de test pour vous. Très utile pour développer sur dev_appserver.

Answer 3

J'utilise GAEUnit pour mon application Google App Engine et je suis assez satisfait de la rapidité des tests. Ce que j’aime dans GAEUnit, et je suis sûr que Webtest le fait, c’est qu’il crée sa propre version pour tous les talons de test, laissant ainsi votre version "live" seule pour le test.

Ainsi, votre banque de données que vous utiliserez peut-être pour le développement restera telle quelle lorsque vous exécuterez vos GAETests.

Answer 4

Je pourrais aussi ajouter que le Luminaire a été très utile dans mes tests unitaires. Il vous permet de créer des modèles dans une syntaxe déclarative, qui convertit stockées dans les entités que vous pouvez charger dans vos tests. De cette façon, vous avez le même ensemble de données au début de chaque cas de test!, ce qui vous évite d'avoir à créer les données par part au début de chaque test. Voici un exemple, à partir de l'appareil de la documentation: Ce modèle:

from google.appengine.ext import db

class Entry(db.Model):
    title = db.StringProperty()
    body = db.TextProperty()
    added_on = db.DateTimeProperty(auto_now_add=True)

Votre appareil devrait ressembler à ceci:

from fixture import DataSet

class EntryData(DataSet):
    class great_monday:
        title = "Monday Was Great"
        body = """\
Monday was the best day ever.
"""

Notez cependant, que j'ai rencontré les problèmes suivants: 1. Ce bug, mais le patch inclus n'y remédier. 2. La banque de données n'est pas, par défaut, zéro entre les cas de test. J'ai donc utiliser cette option pour une remise à zéro pour chaque cas de test:

class TycoonTest(unittest.TestCase):
    def setUp(self):
        # Clear out the datastore before starting the test.
        apiproxy_stub_map.apiproxy._APIProxyStubMap__stub_map['datastore_v3'].Clear()    
        self.data = self.load_data()
        self.data.setup()
        os.environ['SERVER_NAME'] = "dev_appserver"
        self.after_setUp()

    def load_data(self):
        return datafixture.data(*dset.__all__)

    def after_setUp(self):
        """ After setup
        """
        pass

    def tearDown(self):
        # Teardown data.
        try:
            self.data.teardown()
        except:
            pass

Answer 5

L' API SDK 1.4.3 Testbed permet de configurer facilement les bibliothèques de raccord pour les tests d'intégration locaux.