Comment faire des tests unitaires de base de données?
J'ai entendu dire que lors du développement d'une application qui utilise une base de données, vous devriez faire des tests unitaires de base de données. Quelles sont les meilleures pratiques en matière de tests unitaires de base de données? Quelles sont les principales préoccupations lors des tests unitaires db et comment le faire "correctement"?
Quelles sont les meilleures pratiques en matière de tests unitaires de base de données?
Le DbUnit framework (un framework de test permettant de mettre une base de données dans un état connu et d'effectuer une assertion par rapport à son contenu) a une page listant les tests de base de données meilleures pratiques cela, à mon avis l'expérience, sont vraies.
Quelles sont les principales préoccupations lors des tests unitaires DB
- Création d'un schéma à jour, gestion des modifications de schéma
- Configuration des données (données de référence, données de test) et maintien des données de test
- Garder les tests indépendants
- Permettre aux développeurs de travailler simultanément
- Vitesse (les tests impliquant une base de données sont généralement plus lents et rendront votre build plus long)
et comment le faire "bien"?
Comme indiqué, suivez les bonnes pratiques connues et utilisez des outils/cadres dédiés:
- Préférez si possible dans la base de données en mémoire (pour la vitesse)
- Utiliser un schéma par développeur est indispensable (pour permettre un travail simultané)
- Utilisez un outil de "migration de base de données" (à la RoR) pour gérer les modifications de schéma et mettre à jour un schéma vers la version ultime
- Construisez ou utilisez un harnais de test permettant de mettre la base de données dans un état connu avant chaque test et d'effectuer des assertions contre les données après l'exécution (ou d'exécuter des tests dans une transaction que vous annulez à la fin du test).
Une liste des éléments qui doivent être examinés et pris en compte lors du démarrage avec les tests unitaires de la base de données
- Chaque testeur a besoin d'une base de données distincte, afin d'éviter d'interférer avec les activités d'un autre testeur/développeur
- Pour avoir un moyen simple de créer une base de données à tester (cela est lié au fait d'avoir une base de données SQL Server sous contrôle de version). Ceci est particulièrement utile lorsque vous essayez de trouver ce qui s'est mal passé si certains tests échouent
- Concentrez-vous sur des domaines spécifiques et créez des tests pour un seul module au lieu de les couvrir tous en même temps. Ajouter des tests de manière granulaire est un bon moyen d'être efficace
- Assurez-vous de fournir autant de détails que possible en cas d'échec d'un test, pour faciliter le débogage
- Utiliser les mêmes données de test pour tous les tests
Si les tests sont implémentés à l'aide du framework tSQLt, le processus de test unitaire peut être compliqué lorsqu'il s'agit de nombreuses bases de données provenant de plusieurs instances de SQL Server. Afin de maintenir, d'exécuter et de gérer les tests unitaires directement à partir de SQL Server Management Studio, ApexSQL Unit Test peut être utilisé comme solution
Jetez un oeil à ce lien . Il passe en revue certaines des bases de la création de procs stockés de tests unitaires dans SQL Server, ainsi que les différents types de tests unitaires et indique quand les utiliser. Je ne sais pas quel SGBD vous utilisez, mais évidemment cet article est destiné à SQL Server.
Volé de l'article:
Tests de fonctionnalités
La première classe, et probablement la plus répandue, de test unitaire de base de données est un test de fonctionnalité. Dans mon esprit, les tests de fonctionnalité testent les fonctionnalités de base - ou API, si vous voulez - de votre base de données du point de vue du consommateur de base de données. Tester les objets de programmabilité d'une base de données est le scénario principal ici. Ainsi, tester toutes les procédures, fonctions et déclencheurs stockés dans votre base de données constitue pour moi des tests de fonctionnalités. Pour tester une procédure stockée, vous devez exécuter la procédure stockée et vérifier que les résultats attendus ont été renvoyés ou que le comportement approprié s'est produit. Cependant, vous pouvez tester plus que ces types d'objets. Vous pouvez imaginer vouloir vous assurer qu'une vue, par exemple, retourne le calcul approprié à partir d'une colonne calculée. Comme vous pouvez le voir, les possibilités dans ce domaine sont grandes.
Tests de schéma
Un des aspects les plus critiques d'une base de données est son schéma, et les tests pour s'assurer qu'elle se comporte comme prévu est une autre classe importante de tests unitaires de base de données. Ici, vous souhaiterez souvent vous assurer qu'une vue renvoie l'ensemble attendu de colonnes du type de données approprié dans l'ordre approprié. Vous voudrez peut-être vous assurer que votre base de données contient en fait les 1 000 tables que vous attendez.
Tests de sécurité
De nos jours, la sécurité des données stockées dans la base de données est essentielle. Ainsi, une autre classe importante de tests unitaires de base de données est celle qui teste la sécurité de la base de données. Ici, vous souhaiterez vous assurer que des utilisateurs particuliers existent dans votre base de données et que les autorisations appropriées leur sont attribuées. Vous souhaiterez souvent créer des tests négatifs qui tentent de récupérer des données à partir de tables ou de vues restreintes et vous assurer que l'accès est refusé de manière appropriée.
Tests des données boursières
De nombreuses bases de données contiennent des données sur les stocks ou des données sur les semences. Ces données changent rarement et sont souvent utilisées comme données de recherche pour les applications ou les utilisateurs finaux. Les codes postaux et leurs villes et États associés sont de bons exemples de ce type de données. Par conséquent, il est utile de créer des tests pour vous assurer que vos données de stock existent bien dans votre base de données.
Je suis heureux que vous ayez posé des questions sur les tests unitaires et non sur les tests en général.
Les bases de données ont de nombreuses fonctionnalités qui doivent être testées. Quelques exemples:
- Types de données/taille/jeux de caractères (essayez d'insérer un nom suédois, ou de longues URL ou des numéros du monde réel, et voyez si vos définitions de colonne sont correctes)
- Déclencheurs
- Contraintes (clés étrangères, unicité ...)
- Vues (vérifiez que les données sont correctement incluses/exclues/transformées)
- Procédures stockées
- FDU
- Autorisations
- ...
Cela est utile non seulement lorsque vous modifiez quelque chose dans votre base de données, mais également lorsque vous mettez à niveau votre dbms ou modifiez quelque chose dans vos paramètres.
Généralement, les tests d'intégration sont effectués. Cela signifie qu'une suite de tests dans un langage de programmation tel que PHP ou Java est créé et les tests émettent des requêtes. Mais si quelque chose échoue, ou à quelques exceptions près, il est plus difficile de comprendre le problème, pour 2 raisons:
- Le problème pourrait être dans votre PHP PHP, ou dans la configuration PHP, ou dans le réseau, ou ...
- Les instructions SQL sont plus difficiles à lire et à modifier, si elles sont intégrées dans un autre langage de programmation.
Donc, à mon avis, pour les bases de données complexes, vous devez utiliser un framework de tests unitaires écrit en SQL (en utilisant des procédures et des tables stockées). Vous devez le choisir avec soin, car ce type d'outils n'est pas largement utilisé (et donc pas largement testé). Par exemple, si vous utilisez MySQL, je connais ces outils:
- STK/Unit http://stk.wikidot.com/stk-unit
- utMySQL http://utmysql.sourceforge.net/
J'utilise junit/nunit/etc et je code les tests unitaires de base de données avec Java ou c #. Ceux-ci peuvent ensuite s'exécuter sur un serveur d'intégration en utilisant peut-être un schéma distinct pour la base de données de test.
Le dernier développeur Oracle SQL est livré avec un cadre intégré de tests unitaires. J'ai jeté un œil à cela, mais je ne l'utiliserais pas [~ # ~] [~ # ~] . Il utilise une interface graphique pour créer et exécuter des tests et stocke tous les tests dans la base de données, il n'est donc pas si facile de placer des cas de test sous contrôle de version. Il existe probablement d'autres cadres de test, j'imagine qu'ils peuvent être spécifiques à votre base de données.
Les bonnes pratiques sont similaires aux tests unitaires réguliers:
- mettre les tests sous contrôle de source
- faire des tests rapides - ne pas trop tester à la fois
- rendre vos tests reproductibles
Jetez un œil au framework DBTestDriven. Cela fonctionne très bien pour nous. Téléchargez-le depuis GitHub ou leur site Web.
Quant au développement JVM, les tests unitaires peuvent bénéficier de l'abstraction JDBC: dès que vous savez quelles données JDBC sont générées par l'accès DB, ces données JDBC peuvent être "relues".
Ainsi, le cas d'accès à la base de données peut être "reproduit" pour les tests, sans la base de données cible: pas de complexité d'isolement des tests/données, facilite l'intégration continue.
Mon framework Acolyte est un framework utile de cette manière (y compris l'outil GUI studio pour "enregistrer" le résultat de la base de données): https://github.com/cchantep/acolyte