Test unitaire sur le code qui utilise la firebase database

Je suis intéressé de savoir quelle approche les gens prennent dans le développement de tests unitaires automatisés qui exercent la firebase database

Installez-vous une firebase database QA (sharepoint départ connu) avant l’exécution de la suite de tests.

OU

Construisez-vous un stub de firebase database qui se met en place chaque fois qu’un appel à la firebase database se produit?

EDIT: Question connexe, mais pas en double, bien qu’assez importante pour le sujet en question: comment tester la persistance des unités?

Le “stub de firebase database” qui se trouve dans ce document est généralement appelé “référentiel fictif” ou “référentiel simulé”. Ils sont une bonne idée. Vous pouvez les coder à la main (pas difficile pour les cas simples) ou utiliser un framework comme Rhino Mocks pour les générer. Vous ne mentionnez pas la langue dans laquelle vous travaillez. Rhino mocks est pour .Net.

Si vous utilisez des référentiels fictifs, vous pouvez exécuter des tests sur du code qui fonctionne avec des données, sans utiliser réellement une firebase database pour les données. Cela rend les tests très rapides, ce qui est une bonne chose.

Bien sûr, vous devez toujours tester le référentiel réel à un moment donné, et cela pose plus un problème. Ces tests s’exécuteront plus lentement, car ils utilisent une firebase database réelle. Certains classeraient alors comme “tests d’intégration” non pas des tests unitaires en raison des problèmes de vitesse et de dépendance.

Cela ne me dérange pas ce que vous appelez tellement, mais c’est une bonne idée de garder ces tests séparés.

Une bonne idée ici pour la cohérence des données est de commencer une transaction de firebase database avant votre test et de la réactiver par la suite. De cette façon, l’état de la firebase database revient à ce qu’il était avant le test.

Si vous utilisez NHibernate, vous pouvez facilement tester avec une firebase database SQLite en mémoire , ce qui est très rapide.

Nous faisons quelques astuces:

edit: Nous avons des bases de données séparées par utilisateur. Notre serveur de compilation possède également sa propre firebase database. Le coût des disques durs supplémentaires est beaucoup moins élevé que celui des développeurs influençant les tests de chacun.

  1. Notre application peut générer des tableaux et effectuer des étapes de mise à niveau proprement dites (pas de scripts de firebase database séparés). Cela aide notre client, car il lui suffit de déposer un fichier WAR et il a fini. L’application examine la firebase database et exécute toutes les instructions DDL nécessaires avant de démarrer le rest du contexte Spring.
  2. Notre suite de tests contient du code qui décharge le contexte Spring, supprime la firebase database et redémarre le contexte avec une firebase database propre. Nous pouvons éventuellement éteindre cela si nous aimons
  3. Tous nos désinstallations de bases de données / SQL sont des tests d’intégration transactionnelle Spring. Cela signifie que, une fois le test terminé, les transactions sont annulées et que les autres désinstallations examineront à nouveau une firebase database propre.

En plus de tout cela, nous essayons de faire des tests simulés autant que possible, car les démangeaisons ne sont pas vraiment des tests d’intégration. Donc, essayez de séparer votre couche de service de la couche DAO. Cela vous aide également à trouver les problèmes plus facilement, car vous avez tout isolé.

À un moment donné, je pense que vous devez accéder à la firebase database, car nous ne vivons pas dans un monde idéal / académique 🙂

Cela dépend du cas, mais sur les systèmes hérités où je ne souhaite pas extraire la firebase database, j’introduis souvent une interface, disons IFooDBManager qui a des méthodes qui renvoient des entités ADO.Net, comme des tables de données ou des ensembles de données. Bien sûr, cela ne doit pas nécessairement être une interface, mais cela pourrait être une méthode virtuelle par exemple. Puis, dans mes tests, j’utilise une petite API avec une interface fluide que j’ai construite il y a longtemps, je l’utilise pour créer des ensembles de données et des tableaux et les remplir avec des valeurs de test afin que je puisse les retourner de mes faux.

L’interface fluide ressemble à ceci:

return DataTableBuilder.Create() .DefineColumns("a, b") .AddRow().SetValue("a", 1).SetValue("b", 2).DoneWithRow() .AddRow().SetValue("a", 10).SetValue("b", 20).DoneWithRow() .Table 

Comme je l’ai dit, c’est l’une des approches que j’utilise, principalement pour les systèmes hérités où je ne veux pas introduire de nouvelles dépendances sur les trames. C’est cependant une technique que je n’ai pas vu beaucoup d’autres personnes, alors j’ai pensé qu’il serait utile de la mentionner.

EDIT: J’ai oublié de préciser que c’est pour extraire la firebase database, donc l’interaction avec la firebase database n’est pas testée dans ce cas. L’interaction réelle aura lieu dans l’implémentation concrète de IFooDBManager, pour tester que quelque chose d’autre est complètement nécessaire.

En outre, toutes les méthodes sur une telle interface ne renvoient bien sûr pas des choses, mais il existe également des méthodes pour écrire dans la firebase database. Celles-ci sont généralement testées par des tests d’interaction dans RhinoMocks.

En réalité, vous devriez faire les deux. Lorsque vous dites “construire un stub de firebase database”, cela donne à penser à des moqueries dans les tests unitaires. Et lorsque vous parlez de “Installer une firebase database QA (sharepoint départ connu)”, cela donne des indications sur les tests d’intégration auxquels vous avez réellement access dans la firebase database. Les tests unitaires interviennent beaucoup plus tôt dans le jeu et se situent là où la moquerie entre en jeu. Se moquer est beaucoup plus rapide que de bash la firebase database. Ainsi, lorsque vous exécutez de nombreux tests unitaires, la moquerie permet de gagner beaucoup de temps. Rhino Mocks est un excellent cadre que j’ai utilisé personnellement. Mais il existe plusieurs frameworks moqueurs, trouvez celui qui vous convient le mieux.

À un moment donné, vous devez placer votre firebase database complète via des tests d’intégration, et le meilleur moyen que j’ai trouvé pour cela est d’avoir un script qui crée et remplit complètement la firebase database avec un dataset connu. Assurez-vous ensuite que rien ne va toucher votre nouvelle firebase database, à l’exception des tests d’intégration, et testez-la.

Nous nous dirigeons vers l’utilisation de frameworks fictifs – ils simulent des ressources telles que des bases de données, des fichiers de configuration, etc. L’utilisation de ces frameworks est un moyen pratique d’exécuter efficacement vos tests unitaires.

Rhino Mocks est l’un des frameworks sur lesquels nous travaillons. Vous pouvez lire à ce sujet dans le lien ci-dessous. Il explique également pourquoi vous avez besoin de tels frameworks.

http://weblogs.asp.net/stephenwalther/archive/2008/03/22/tdd-introduction-to-rhino-mocks.aspx

J’utilise généralement deux approches.

Le code qui dépend de la couche d’abstraction de la firebase database fonctionne avec IoC et est donc facilement testable avec des simulations / stubs. Vous avez une interface IDataAccess ou IRepository et vous testez les interactions de votre code avec celle-ci.

Le code qui fonctionne réellement sur la firebase database (par exemple, une classe implémentant IDataAccess ) est testé seul, effectuant généralement des allers-retours vers la firebase database (insert-resortingeve-update-resortingeve-delete). Avant d’exécuter chaque test élémentaire, la firebase database est recréée ou vidée pour éviter les interférences de test. Cela conduit à des tests nécessitant quelques minutes pour s’exécuter au lieu de quelques secondes, mais à mon avis, il est important de tester la firebase database réelle que vous utiliserez en production. L’utilisation d’un remplacement tel que SQLite en mémoire n’est pas un bon choix car il est trop différent, par exemple, de SQL Server.

Voici un bon écran sur ce sujet appelé La valeur des petits tests

Dans ma pratique de test de firebase database, j’ai utilisé NUnit et avant l’exécution de toute la séquence de tests, la firebase database était installée et remplie de données de test. Certes, ce processus n’a pas été très rapide, mais ce qui vous empêche de faire d’autres travaux pendant que les tests sont en cours.

Spring a des classes de test transactionnelles. Saisissez les données de test, lancez les tests, restaurez-les. C’est comme si tu n’étais jamais là.

Si vous essayez de tester le code d’access aux données, vous aurez besoin d’un cadre de simulation . Dans le lien suivant, vous pouvez voir un didacticiel vidéo sur les bases de données de tests unitaires