Tests unitaires et base de données

Question

Cette question sur les tests unitaires a déclenché une autre chose qui me tracasse. Je suis revenu en arrière sur trois façons de faire des tests unitaires en frappant une base de données.

1. Créer des objets fantaisie et de les brancher. Ceci a l'avantage de ne pas avoir besoin d'une base de données, mais le temps de ce long et je ne sais pas à quel point le retour sur investissement que je reçois. Je reçois du CIO et dans moq un peu, mais il semble encore douloureux.
2. Créer une configuration et des scripts de base de données teardown pour créer des cas connus et test pour ceux-ci. Encore une fois, peut prendre beaucoup de temps, mais encore plus facile de créer de faux objets la plupart du temps. Et d'autres personnes au travail peuvent encore exécuter en supposant qu'ils ont serveur SQL sur leur localhost.
3. manuellement vérifier la base de données de dev et modifier les tests unitaires. Intensivement travail manuel, mais si j'ai un « ensemble de test » qui ne change pas, il semble fonctionner correctement. Sur ma machine, au moins :-).

Je sais que l'option 1 est la façon « correcte » pour faire des tests unitaires, mais des trois, qui est probablement l'option que je l'ai utilisé le moins (même si les derniers projets ont été avec la COI, de sorte que la porte est ouverte pour moi ). Je me rends compte beaucoup de cela dépend de ce qui est moqué exactement et ce qui est testé, mais qu'est-ce que je manque ici?

Si le contexte aide, je suis dans un magasin C #, l'écriture d'applications en interne, seuls quelques développeurs.

Answer 1

La première ne devrait pas être difficile si vous avez un accès aux données de couche qui expose une poignée de méthodes de IQueryable<T>. Il y a un truc agréable que vous pouvez utiliser pour les données de faux: il suffit de stocker les objets d'entité dans un List<T> de AsQueryable et de l'utilisation. Je trouve cela plus facile que moq pour les parties de données.

En ce qui concerne CIO, je prends la position qu'il est actuellement galvaudé (être conscient que mon opinion représente la minorité de programmeurs à cet égard). Vous pouvez utiliser un outil comme taupes lors des tests de simulation sans avoir à la violence la conception de votre programme. Je n'utilise pas du CIO à moins que la conception appelle en fait pour elle.

Answer 2

Je certainement continuer à utiliser de véritables tests unitaires (option 1). Je aime les conseils de Stephen pour cela.

Vous pouvez également trouver des tests d'intégration avec une base de données réelle (option 2) nécessaires à utiliser aussi bien (option 2). Pourquoi? Du fait partie de ce que vous devez tester (O / cartographie R, avec le schéma compatibilité DB réel, etc.) ne sont pas couverts par de vrais tests unitaires.

En ce qui concerne la configuration et la logique de désassemblage, héritant de cela suffit généralement (en utilisant .NET, NUnit et SqlServer pour la base de données):

using System.Transactions;
using NUnit.Framework;
namespace Crown.Util.TestUtil
{
    [TestFixture]
    public class PersistenceTestFixture
    {
        public TransactionScope TxScope { get; private set; }

        [SetUp]
        public void SetUp()
        {
            TxScope = new TransactionScope();
        }

        [TearDown]
        public void TearDown()
        {
            if (TxScope != null)
            {
                TxScope.Dispose();
                TxScope = null;
            }
        }
    }
}

Simple comme bonjour.

Answer 3

Il y a toute une série de réponse à cette question. La première chose à faire est d'exprimer clairement ce que vous testez. Est-ce la façade d'une API qui a une base de données derrière elle, les objets DAO, la structure de votre base de données?

Apprendre à cela aussi vous aider à choisir la meilleure façon de choses de test. Il y a aussi de ce que je peux voir une alternative à ceux que vous énumérez. C'est de commencer dans la base de données dans la mémoire tels que hsql et exécuter vos cours et des tests contre cela. Cela signifie que vous pouvez créer la structure de base de données au début de vous tests. Parce qu'il est en mémoire que vous n'avez pas à vous soucier d'avoir un serveur de base de données, il est rapide, et vous pouvez le charger à votre test avec des données spécifiques.

J'utilise se moque tout à fait un peu et alors qu'ils sont parfaits pour les tests unitaires d'une classe, dans certains cas, ils ne sont pas. Ils peuvent aussi manquer conduire assez facilement. Il est pas rare de voir quelque chose qui fonctionne avec des simulacres, de ne pas travailler quand elle est intégrée. Le reasonnfor est que vous chargez la maquette avec certaines attentes et réponses, que vous avez peut-être à tort intepreted de la chose que la maquette représente.

Ne vous méprenez pas, je aime se moque et de les utiliser un peu. Mais ce faisant, vous ne devez jamais supposer que parce que quelque chose est testé unitairement, il est correct. Il ne augmente les chances, mais les tests d'intégration vous donnent effectivement l'assurance à 100%.

Answer 4

Qu'est-ce que vous testez vraiment qui vous fait sentir que cela est difficile?

Si vous découpler votre entreprise et la logique de la couche service à partir de votre code de persistence, vous devriez easilly pouvoir isoler le code que vous voulez tester l'unité sans avoir à un DB.

L'un des principes les plus importants de tests unitaires est de découpler et d'essai en vase clos. Lorsque vous avez une compréhension claire de la façon de le faire, les tests unitaires est facile. Lorsque vous ne faites pas, les tests unitaires devient difficile.