sql server - Comment puis-je tester la persistance unitaire?

Translate

En tant que novice dans la pratique du développement basé sur les tests, je me retrouve souvent dans un dilemme quant à la façon de tester la persistance d'unité dans une base de données.

Je sais que techniquement ce serait un test d'intégration (pas un test unitaire), mais je veux découvrir les meilleures stratégies pour ce qui suit:

  1. Tester les requêtes.
  2. Inserts de test. Comment savoir si l'insert a mal tourné s'il échoue? Je peux le tester en l'insérant puis en interrogeant, mais comment puis-je savoir que la requête n'était pas erronée?
  3. Test des mises à jour et des suppressions - identique au test des insertions

Quelles sont les meilleures pratiques pour y parvenir?


En ce qui concerne les tests SQL: je suis conscient que cela pourrait être fait, mais si j'utilise un mappeur O / R comme NHibernate, il attache des verrues de dénomination dans les alias utilisés pour les requêtes de sortie, et comme cela est quelque peu imprévisible, je ne suis pas sûr Je pourrais tester cela.

Dois-je simplement, tout abandonner et simplement faire confiance à NHibernate? Je ne suis pas sûr que ce soit prudent.

This question and all comments follow the "Attribution Required."

Toutes les réponses

Translate

Regardez dans DB Unit. C'est une bibliothèque Java, mais il doit y avoir un équivalent C #. Il vous permet de préparer la base de données avec un ensemble de données afin que vous sachiez ce qu'il y a dans la base de données, puis vous pouvez vous connecter avec DB Unit pour voir ce qu'il y a dans la base de données. Il peut s'exécuter sur de nombreux systèmes de base de données, vous pouvez donc utiliser votre configuration de base de données réelle, ou utiliser autre chose, comme HSQL en Java (une implémentation de base de données Java avec une option en mémoire).

Si vous souhaitez tester que votre code utilise correctement la base de données (ce que vous devriez probablement faire), c'est la manière d'isoler chaque test et de vous assurer que la base de données a préparé les données attendues.

La source
Translate

CommeMike Stone a dit, DbUnit est idéal pour mettre la base de données dans un état connu avant d'exécuter vos tests. Lorsque vos tests sont terminés, DbUnit peut remettre la base de données dans l'état dans lequel elle se trouvait avant d'exécuter les tests.

DbUnit (Java)

DbUnit.NET

La source
Translate

Vous effectuez le test unitaire en simulant la connexion à la base de données. De cette façon, vous pouvez créer des scénarios dans lesquels des requêtes spécifiques dans le flux d'un appel de méthode réussissent ou échouent. Je construis généralement mes attentes fictives de sorte que le texte de la requête soit ignoré, car je veux vraiment tester la tolérance aux pannes de la méthode et comment elle se gère - les spécificités du SQL ne sont pas pertinentes à cette fin.

Évidemment, cela signifie que votre test ne vérifiera pas réellement que la méthodetravaux, car le SQL peut être erroné. C'est là que les tests d'intégration entrent en jeu. Pour cela, je m'attends à ce que quelqu'un d'autre ait une réponse plus approfondie, car je commence tout juste à m'y mettre moi-même.

La source
Translate

J'ai écrit un article ici concernanttest unitaire de la couche de donnéesqui couvre exactement ce problème. Toutes mes excuses pour le plug (honteux), mais l'article est trop long à publier ici.

J'espère que cela vous aidera - cela a très bien fonctionné pour moi au cours des 6 derniers mois sur 3 projets actifs.

Cordialement,

Rob G

La source
Translate

Le problème que j'ai rencontré lors des tests unitaires de persistance, en particulier sans ORM et donc en se moquant de votre base de données (connexion), est que vous ne savez pas vraiment si vos requêtes réussissent. Il se peut que vos requêtes soient spécifiquement conçues pour une version de base de données particulière et ne réussissent qu'avec cette version. Vous ne le découvrirez jamais si vous vous moquez de votre base de données. Donc, à mon avis, la persistance des tests unitaires n'a qu'une utilité limitée. Vous devez toujours ajouter des tests exécutés sur la base de données ciblée.

La source
Translate

PourNHibernate, Je recommanderais vraiment de se moquer de laNHibernate APIpour les tests unitaires - faites confiance à la bibliothèque pour faire ce qu'il faut. Si vous voulez vous assurer que les données vont effectivement dans la base de données, effectuez un test d'intégration.

La source
Translate

Pour les projets basés sur JDBC, mon framework Acolyte peut être utilisé:http://acolyte.eu.org. Il permet de simuler l'accès aux données que vous souhaitez tester, en bénéficiant de l'abstraction JDBC, sans avoir à gérer un DB de test spécifique.

La source
Translate

Je me moquerais également de la base de données et vérifierais que les requêtes correspondent à vos attentes. Il y a un risque que le test vérifie le mauvais SQL, mais cela serait détecté dans les tests d'intégration

La source
Dan
Translate

Techniquement, les tests unitaires de persistance ne sont pas des tests unitaires, mais des tests d'intégration.

Avec C # utilisant mbUnit, vous utilisez simplement les attributs SqlRestoreInfo et RollBack

    [TestFixture]
    [SqlRestoreInfo(<connectionsting>, <name>,<backupLocation>]
    public class Tests
    {

        [SetUp]
        public void Setup()
        {

        }

        [Test]
        [RollBack]
        public void TEST()
        {
           //test insert. 
        }
    }

La même chose peut être faite dans NUnit, sauf que les noms d'attributs diffèrent légèrement.

Pour vérifier si votre requête a abouti, vous devez normalement la suivre avec une deuxième requête pour voir si la base de données a été modifiée comme prévu.

La source
Translate

Je crée généralement un référentiel et l'utilise pour enregistrer mon entité, puis en récupérer un nouveau. Ensuite, j'affirme que le récupéré est égal au sauvé.

La source