Contrats de code .NET 4.0 - Quel sera leur impact sur les tests unitaires?

Question

Par exemple cet article introduit.

Quel est l'avantage?

L'analyse statique semble cool, mais en même temps, il permettrait d'éviter la possibilité de passer la valeur null comme paramètre dans l'unité de test. (si vous avez suivi l'exemple dans l'article que c'est)

Alors que sur le sujet des tests unitaires - compte tenu de la façon dont les choses sont maintenant, il y a sûrement aucun point pour les contrats de code si vous avez déjà la pratique de tests automatisés?

Mise à jour

Après avoir joué avec des Contrats de Code, je suis un peu déçu. Par exemple, sur la base du code de la accepté de répondre:

public double CalculateTotal(Order order)
{
    Contract.Requires(order != null);
    Contract.Ensures(Contract.Result<double>() >= 0);
    return 2.0;
}

Pour les tests unitaires, vous toujours avoir à écrire des tests pour s'assurer que nul ne peut être adopté, et le résultat est supérieur ou égal à zéro si les contrats sont de la logique métier. En d'autres termes, si j'étais à supprimer le premier contrat, pas de tests allait se briser, si je n'avais pas spécialement eu un test de cette fonctionnalité. Ceci est basé sur la non utilisation de l'analyse statique intégré dans le meilleur (ultimate etc...) les éditions de Visual Studio mais.

Essentiellement, ils se résument toutes à une autre façon de l'écriture traditionnelle si les déclarations. Mon expérience fait à l'aide de TDD, avec des Contrats de Code montre pourquoi et comment je suis allé à ce sujet.

Answer 1

Je ne pense pas que les tests unitaires et les contrats d'interférer les uns avec les autres tant que ça, et si quelque chose de contrats devraient aider les tests unitaires car il élimine le besoin d'ajouter fastidieux essais répétitifs pour les arguments non valides. Contrats de spécifier le montant minimum que vous pouvez attendre de la fonction, alors que les tests unitaires tenter de valider le comportement réel pour un ensemble particulier de données. Considérons cet exemple artificiel:

public class Order
{
    public IEnumerable Items { get; }
}

public class OrderCalculator
{
    public double CalculateTotal(Order order)
    {
    	Contract.Requires(order != null);
    	Contract.Ensures(Contract.Result<double>() >= 0);

    	return 2.0;
    }
}

Clairement le code remplit le contrat, mais vous auriez encore besoin de tests unitaires pour valider il se comporte effectivement comme vous le souhaitez.

Answer 2

Quel est l'avantage?

Disons que vous voulez vous assurer qu'une méthode ne retourne jamais null. Maintenant, avec les tests unitaires, vous devez écrire un tas de cas de test lorsque vous appelez la méthode avec des variables d'entrées et de vérifier que la sortie n'est pas nulle. La difficulté est, vous ne pouvez pas tester toutes les entrées possibles.

Avec des contrats de code, vous venez de déclarer que la méthode ne retourne jamais null. L'analyseur statique va ensuite se plaindre si il n'est pas possible de prouver que. Si elle ne se plaint pas, vous savez que votre affirmation est correcte pour toutes les entrées possibles.

Moins de travail, d'une parfaite correction de garanties. Quoi de ne pas aimer?

Answer 3

Les contrats vous permettent de vous dire quel est le véritable but de ce code est, par opposition à laisser ce que le code fait avec ce que l'aléatoire arguments sont remis debout que la définition du point de vue du compilateur, ou le prochain lecteur de code. Cela permet de nettement mieux statique de l'analyse et de l'optimisation du code.

Par exemple, si je déclare un paramètre de type entier (à l'aide du contrat de notation) pour être dans la gamme de 1 à 10, et j'ai un local de tableau dans ma fonction déclarée de la même taille, qui est indexé par le paramètre, le compilateur ne peut pas dire qu'il n'y a pas de possibilité de l'indice d'erreur, produisant ainsi un meilleur code.

Vous pouvez indiquer que la valeur null est une valeur valide dans un contrat.

Le but de l'unité de test est de vérifier dynamiquement que le code réalise quel but déclaré qu'il possède. Juste parce que vous avez écrit un contrat pour une fonction, ne signifie pas que le code ne soit que, ou que l'analyse statique peut vérifier le code ne fait que. Les tests unitaires ne va pas loin.

Answer 4

Eh bien, il ne sera pas interférer avec les tests unitaires en général. Mais comme j'ai vu que vous avez mentionné quelque chose à propos de TDD.

Si je pense à ce sujet à partir de ce point de vue, je pense que cela pourrait/peut modifier la procédure de la norme d'un

• la méthode create (juste la signature)
• créer des unités de test -> mettre en œuvre le test
• exécutez le test: ne parviennent pas laisser
• mettre en œuvre la méthode, pirater à la fin, juste pour le faire fonctionner
• exécuter le test: le voir passer
• refactoriser votre (peut-être salissant) corps de la méthode
• (re-exécuter le test juste pour voir, vous n'avez pas cassé quelque chose)

Ce serait vraiment dur complet de l'unité-la procédure d'essai. Dans un tel contexte, je pense que l'on peut insérer du code de contrats entre le 1er et le 2ème point, comme

• la méthode create (juste la signature)
• insérer des contrats de code pour les méthodes des paramètres d'entrée
• créer des unités de test -> mettre en œuvre le test
• ...

L'avantage que je vois à l'instant, c'est que vous pouvez écrire plus facilement des tests unitaires dans le sens que vous ne pas avoir à vérifier chaque chemin possible puisque certains sont déjà pris en compte par vos contrats. Il vous donne un contrôle supplémentaire, mais il ne serait pas remplacer l'unité de test car il y aura toujours plus de logique dans le code, plus de chemin que doivent être testés avec des tests unitaires, comme d'habitude.

Modifier

Une autre possibilité que je n'ai pas en compte avant d'ajouter le code des contrats dans le refactoring partie. Fondamentalement, en tant que moyen supplémentaire d'assurer choses. Mais qui serait en quelque sorte être redondant et puisque les gens n'aiment pas faire redondant choses...