NUnit Tester L'Exécution De L'Ordre

Par défaut nunit les tests s'exécutent dans l'ordre alphabétique. Personne ne sait de toute façon de définir l'ordre d'exécution? Un attribut existe pour cela?

  • Pourquoi voudriez-vous faire cela? Il semble que vous avez une dépendance sur l'ordre d'exécution, ce qui est une mauvaise chose. Vous avez besoin de reconsidérer pourquoi vous voulez cette. Les tests unitaires doivent s'exécuter dans l'isolement et d'être totalement indépendant des autres. Il semble que vous créez des candidats pour le test d'odeur Erratique Tests.
  • Cela ressemble à un doublon, mais vous pouvez voir ma réponse à cette here
  • devrait != doit. Et ce n'est pas vraiment de l'événement doit, parce qu'en fait, presque tous les tests d'intégration sont exécutées dans un ordre - vous demander de l'équipe QA si ils aléatoirement l'ordre de leurs tests.
  • J'ai actuellement quelques tests dont le but semble d'importance, même si il ne devrait pas. Personnellement, j'aimerais un moyen de rendre aléatoire l'ordre de contrôle spécifiquement pour m'aider à faire en sorte que mes tests ne SONT PAS en quelque sorte dépendant de l'ordre. Bien sûr, ce que j'aimerais VRAIMENT serait un lanceur de test pour exécuter tous mes essais dans un ordre aléatoire jusqu'à ce qu'il détecte un problème, ou je dis stop. Si j'ai couru, que du jour au lendemain, tout était encore vert dans la matinée, alors je pourrais être convaincu que j'ai éliminé le dernier des effets secondaires indésirables.
  • cette question serait plus pertinents si la question a été mise à jour pour préciser que nous parlons de tests d'intégration ici... Nous connaissons tous les règles sur les tests unitaires, au moins si vous avez lu XUnit des modèles de test et de suivi de l'Oncle Bob, etc.. faire.. mais des frameworks tels que NUnit sont également très utiles pour obtenir des tests d'intégration et de courir très vite.. et vous ne voulez certainement pas de ceux qui doivent être aléatoire, surtout quand un cher de la base de données de configuration est impliqué..
InformationsquelleAutor Riain McAtamney | 2009-07-03
  1. 48

    Vos tests unitaires doivent être en mesure de fonctionner de manière indépendante et autonome. S'ils satisfont à ce critère, l'ordre n'a pas d'importance.

    Il y a des occasions, cependant, lorsque vous voulez exécuter certains tests en premier. Un exemple typique est l'Intégration Continue de la situation où certains tests sont plus longues que d'autres. Nous utilisons l'attribut de catégorie, de sorte que nous pouvons exécuter les tests qui utilisent les moqueries à l'avance les tests qui utilisent la base de données.

    c'est à dire mettre ceci au début de votre tests rapides

    [Category("QuickTests")]

    Où vous avez tests qui dépendent de certaines conditions environnementales, envisager la TestFixtureSetUp et TestFixtureTearDown des attributs, qui vous permettent de marquer les méthodes qui doivent être exécutées avant et après vos tests.

    • J'ai tendance à ne pas utiliser ces attributs, c'est un blog intéressant post- jamesnewkirk.typepad.com/posts/2007/09/why-you-should-.html. Bon point à propos de catégorie de tests.
    • Un autre exemple de commande dépendant de test est quand vous voulez utiliser votre nunit cadre d'exécuter un Test d'Intégration...
    • J'ai tendance à faire des tests plus quand je fais ça, et de s'appuyer sur l'existant, les tests unitaires, autant que possible, afin que je puisse écrire de moins en moins de tests. Ensuite, chaque cycle complet peut échouer séparément. J'ai aussi essayer de concevoir mes données de sorte qu'il peut vivre séparément à partir des données existantes, plutôt que suivant sur les données existantes.
    • Si vous n'avez pas l'exécution de vos tests dans un ordre aléatoire, comment pouvez-vous vérifier qu'ils fonctionnent réellement lors de l'exécution de l'ordre? Ce que vous dites est analogue à dire "Si votre logiciel n'a pas de bugs, le test est uneccessary".
    • Si vous avez une panne qui se produit au hasard, comment voulez-vous dire quand vous avez résolu?
    • Voir, par exemple, comment c'est fait dans RSpec. Ce que vous faire est d'utiliser un générateur aléatoire de décider de l'ordre. Si vous avez des problèmes avec un ordre particulier, écrivez la graine et de fonctionner uniquement avec de la graine jusqu'à ce que le problème est résolu. Ce n'est pas une approche parfaite, puisqu'il repose sur le hasard pour trouver des erreurs, mais c'est beaucoup mieux que de l'exécution des tests dans le même ordre à chaque fois.
    • Un autre exemple de cas de test de l'ordre des questions, c'est quand le code cible est à l'aide de classes statiques. Un constructeur statique est créé automatiquement avant la première instance est créée ou tous les membres statiques sont référencés. Si par exemple la vérification de la logique constructeur, vous voulez que les cas de test pour être le premier à exécuter.
    • Ma raison pour la spécification de l'ordre est exécuté à temps. Si vous exécutez 8 en parallèle et que le dernier test en file d'attente la plus longue course de test que vous avez, il va courir sur son propre. Où si vous avez exécuté le plus long de l'exécution des tests en parallèle pour commencer, toutes les épreuves les plus courtes de remplir l'espace mort.
    • Je ne pense pas que faire des tests plus grand devrait jamais être une décision que vous voulez recourir à l'. Le plus granulaire vos tests sont, plus vite vous serez en mesure de dire ce qui est cassé quand on regarde les rapports. Si j'ai un test qui contient 100 étapes et échoue quelque part entre les deux, ça va me prendre beaucoup plus de temps pour la trouver et de la difficulté à tirer que de regarder les test n ° 45 sur 100 essais.
    • Cela va juste pour montrer comment les tests unitaires en soi sont utiles pour un ensemble beaucoup plus que simplement des tests unitaires. Vous pouvez les utiliser pour toutes sortes de choses telles que les données de configuration, les données de démolir, tâches planifiées, tests de performance, tests de charge, model based testing... les limites sont infinies!

    InformationsquelleAutor NeedHack
  2. 166

    Je veux juste souligner que, bien que la plupart des intervenants suppose que ces ont été les tests unitaires, la question ne précise pas qui ils étaient.

    nUnit est un excellent outil qui peut être utilisé pour une variété de situations de test. Je peux voir de bonnes raisons pour vouloir test de contrôle de la commande.

    Dans ces situations que j'ai eu à recourir à intégrer un ordre d'exécution dans le nom de test. Il serait bon d'être en mesure de spécifier l'ordre d'exécution à l'aide d'un attribut.

    • Vous voulez dire que vous avez appelé de vos tests, par exemple, 001_first_test 002_second_test et ainsi de suite?
    • Oui, c'est vrai, bien que je l'utilise généralement un modèle qui me permet d'insérer facilement des tests si nécessaire, de sorte que peut-être 010_first_test, 020_second_test, etc.
    • C'est réellement un bon travail, mais NUnit peut casser à tout moment -- c'est sans-papiers. J'ai fini par aller avec MbUnit, parce que je peux spécifier les dépendances des tests.
    • Voulais aussi mentionner que je ne voudrais pas mettre un nombre dans le texte du nom de test. Donc 010_test_name, 020_test_name, etc.
    • Merci pour la seule saine d'esprit de réponse ici. C'est une question spécifique, pourtant, d'une certaine vague pédant réponses sont upvoted. Oui, nous savons tous ce que les tests unitaires doivent être, ce n'est pas la question.
    • Vous devez vous pas s'appuyer sur la course d'ordre alphabétiques. Nombreux sont les coureurs de l'épreuve de l'exécution des tests simultanément sur de nombreux threads ou processus, et pas nécessairement dans l'ordre alphabétique. Par exemple, NCrunch priorise les tests basés sur le code vous changer (tests impactés), alors qu'ils n'ont pas réussi la dernière fois, alors qu'ils courir vite ou lentement. Si vous voulez un ordre défini, il suffit de créer un méta-coureur pour les essais et les exclure de la des passages réguliers.
    • Une autre bonne raison de spécifier l'ordre est d'attraper certains problèmes avant de continuer avec le reste de la suite de test. en d'autres termes, si mon test pour créer un utilisateur échoue, alors je n'ai pas besoin tout le reste à courir avant que je trouve sur ce résultat. Dans mon autre test que j'ai probablement se moquer de l'utilisateur, mais c'est important pour moi que ce sera le premier test à l'échec - en particulier lors de la suite de test est grande.

    InformationsquelleAutor Les
  3. 105

    NUnit 3.2.0 ajouté une OrderAttribute, voir:

    https://github.com/nunit/docs/wiki/Order-Attribute

    Exemple:

    public class MyFixture
{
    [Test, Order(1)]
    public void TestA() { ... }


    [Test, Order(2)]
    public void TestB() { ... }

    [Test]
    public void TestC() { ... }
}
    • Merci, à droite, au point de ce que je cherchais - et pas de discussions, pourquoi c'est bon ou mauvais 🙂
    • Et puis ils font un entier , au lieu de la virgule, donc si quelqu'un a d'insérer de test, tous les essais doivent être re-numérotées.
    • Vous pouvez toujours commencer avec un très grand nombre, comme des millions ou quelque chose si vous voulez introduire moyen des éléments de cette façon, à peine plus de la frappe. Imo il devrait y avoir un moyen plus facile de commander des choses que d'utiliser des numéros de priorité comme une méthode de l'arbre des dépendances, mais chacun a sa propre dis/avantages.
    • Bonne réponse, mais méfiez-vous, documentation, essais de ne pas attendre les tests avant de terminer.
    • Il fonctionne pour moi, merci
    InformationsquelleAutor Răzvan Flavius Panda
  4. 21

    Vouloir les tests à exécuter dans un ordre précis ne veut pas dire que les tests sont dépendantes les unes des autres - je suis en train de travailler sur un TDD projet pour le moment, et d'être un bon TDDer j'ai raillé/écrasa de tout, mais il serait plus lisible si je pouvais spécifier l'ordre qui les résultats des tests sont affiche - par thème et non par ordre alphabétique. Jusqu'à présent, la seule chose que je peux penser à est de préfixer a_ b_ c_ à des classes pour les classes, les espaces de noms et les méthodes. (Pas sympa) je pense que [TestOrderAttribute] attribut serait sympa - pas strictement suivie par le cadre, mais un soupçon de sorte que nous pouvons atteindre cet

    InformationsquelleAutor William
  5. 10

    Indépendamment de si oui ou non les Tests sont de l'ordre dépendant... certains d'entre nous veulent tout contrôler, d'une manière ordonnée.

    Les tests unitaires sont généralement créés par ordre de complexité. Alors, pourquoi ne devraient-ils pas également être exécutées dans un ordre de complexité, ou l'ordre dans lequel ils ont été créés?

    Personnellement, j'aime voir les tests s'exécutent dans l'ordre dans lequel je les ai créées. En mode TDD, chaque test est naturellement va être plus complexe, et de prendre plus de temps à s'exécuter. Je verrais plutôt la plus simple de tester l'échec en premier car il sera un meilleur indicateur quant à la cause de l'échec.

    Mais, je vois aussi l'avantage de les exécuter dans un ordre aléatoire, surtout si vous voulez tester vos tests n'ont pas de dépendances sur d'autres tests. Que diriez-ajout d'une option pour les coureurs de l'épreuve de "l'Exécution des Tests au Hasard Jusqu'à l'arrêt"?

    • Je ressens la même chose
    InformationsquelleAutor Mont Pierce
  6. 9

    Je suis en train de tester avec du Sélénium sur une assez complexe de site web et l'ensemble de la suite de tests peuvent durer plus d'une demi-heure, et je ne suis pas près à couvrir l'ensemble de l'application. Si je dois veiller à ce que tous les formulaires sont remplis correctement pour chaque test, ce qui ajoute beaucoup de temps, et pas seulement une petite quantité de temps, à l'ensemble de test. Si il y a trop de frais généraux pour lancer les tests, les gens ne fonctionnent pas aussi souvent qu'ils le devraient.

    Donc, je les ai mis dans l'ordre et dépendent de précédents tests d'avoir des zones de texte et dûment remplie. J'utilise Affirmer.Ignore() lors de la pré-conditions ne sont pas valides, mais j'ai besoin de les avoir en cours d'exécution.

    • Totalement. Je suis dans le même bateau ici.
    • Moi aussi! Exactement pourquoi j'ai atterri sur cette question!
    • si vous utilisez visual studio avec nunit, dump nunit et l'utilisation de MS tests. ensuite, vous pouvez utiliser visual studio orderedtest fichier à organiser des cas de test dans l'ordre que vous désirez exécuté
    • Merci! Je vais regarder à cela.
    InformationsquelleAutor Anthony Biagioli
  7. 9

    J'aime vraiment la réponse précédente.

    J'ai changé un peu pour être en mesure d'utiliser un attribut pour définir l'ordre gamme:

    namespace SmiMobile.Web.Selenium.Tests
{
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using NUnit.Framework;
public class OrderedTestAttribute : Attribute
{
public int Order { get; set; }
public OrderedTestAttribute(int order)
{
Order = order;
}
}
public class TestStructure
{
public Action Test;
}
class Int
{
public int I;
}
[TestFixture]
public class ControllingTestOrder
{
private static readonly Int MyInt = new Int();
[TestFixtureSetUp]
public void SetUp()
{
MyInt.I = 0;
}
[OrderedTest(0)]
public void Test0()
{
Console.WriteLine("This is test zero");
Assert.That(MyInt.I, Is.EqualTo(0));
}
[OrderedTest(2)]
public void ATest0()
{
Console.WriteLine("This is test two");
MyInt.I++; Assert.That(MyInt.I, Is.EqualTo(2));
}
[OrderedTest(1)]
public void BTest0()
{
Console.WriteLine("This is test one");
MyInt.I++; Assert.That(MyInt.I, Is.EqualTo(1));
}
[OrderedTest(3)]
public void AAA()
{
Console.WriteLine("This is test three");
MyInt.I++; Assert.That(MyInt.I, Is.EqualTo(3));
}
[TestCaseSource(sourceName: "TestSource")]
public void MyTest(TestStructure test)
{
test.Test();
}
public IEnumerable<TestCaseData> TestSource
{
get
{
var assembly =Assembly.GetExecutingAssembly();
Dictionary<int, List<MethodInfo>> methods = assembly
.GetTypes()
.SelectMany(x => x.GetMethods())
.Where(y => y.GetCustomAttributes().OfType<OrderedTestAttribute>().Any())
.GroupBy(z => z.GetCustomAttribute<OrderedTestAttribute>().Order)
.ToDictionary(gdc => gdc.Key, gdc => gdc.ToList());
foreach (var order in methods.Keys.OrderBy(x => x))
{
foreach (var methodInfo in methods[order])
{
MethodInfo info = methodInfo;
yield return new TestCaseData(
new TestStructure
{
Test = () =>
{
object classInstance = Activator.CreateInstance(info.DeclaringType, null);
info.Invoke(classInstance, null);
}
}).SetName(methodInfo.Name);
}
}
}
}
}
}
    • Je pense que cette approche est grand. Notez bien que le code de réflexion va tirer toutes les méthodes avec l'attribut, donc si vous essayez d'exécuter un test spécifique luminaire, vous pourriez être surpris de trouver qu'il s'exécute plus que vous ne le pensiez. Vous pouvez facilement modifier la requête LINQ si ce n'est pas le comportement souhaité. Voir les liens dans ma réponse pour plus d'info.
    • OrderedTest n'est plus pris en charge dans NUnit 3.
    InformationsquelleAutor PvtVandals
  8. 7

    Je sais que c'est un relativement vieux post, mais voici une autre façon de garder votre test dans l'ordre, SANS faire le test noms maladroit. À l'aide de la TestCaseSource attribut et ayant pour objet de vous passer en avoir un délégué (Action), vous pouvez tout à fait non seulement le contrôle de l'ordre, mais aussi le nom du test ce que c'est.

    Cela fonctionne parce que, selon la documentation, les éléments de la collection retourné à partir de la source de test s'exécute toujours dans l'ordre de la liste.

    Voici une démo à partir d'une présentation, je suis en train de faire demain:

    using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using NUnit.Framework;
namespace NUnitTest
{
public class TestStructure
{
public Action Test;
}
class Int
{
public int I;
}
[TestFixture]
public class ControllingTestOrder
{
private static readonly Int MyInt= new Int();
[TestFixtureSetUp]
public void SetUp()
{
MyInt.I = 0;
}
[TestCaseSource(sourceName: "TestSource")]
public void MyTest(TestStructure test)
{
test.Test();
}
public IEnumerable<TestCaseData> TestSource
{
get
{
yield return new TestCaseData(
new TestStructure
{
Test = () =>
{
Console.WriteLine("This is test one");
MyInt.I++; Assert.That(MyInt.I, Is.EqualTo(1));
}
}).SetName(@"Test One");
yield return new TestCaseData(
new TestStructure
{
Test = () =>
{
Console.WriteLine("This is test two");
MyInt.I++; Assert.That(MyInt.I, Is.EqualTo(2));
}
}).SetName(@"Test Two");
yield return new TestCaseData(
new TestStructure
{
Test = () =>
{
Console.WriteLine("This is test three");
MyInt.I++; Assert.That(MyInt.I, Is.EqualTo(3));
}
}).SetName(@"Test Three");
}
}
}
}
    • J'utilise ce modèle pour en parallèle des tests d'intégration qui prendrait beaucoup trop de temps à exécuter de façon linéaire. Tous les tests sont sur un type j'ai donc utiliser une Action<T>, et chaque Action a une clé qui dit ce qui est fait "ShouldBeFoo". De cette façon, ce que le test ne sera visible dans le nom du test, et le TestCaseSource peut être filtrée pour différents types de tests sont regroupés. Ironiquement, je ne se soucient pas de l'ordre d'exécution, mais convenez qu'il serait de travailler.
    • À l'aide de la TestCaseSource comme un moyen d'exécuter commandé des tests est un coup de génie. Bien fait. J'ai pris cette approche avec celle ci-dessous et ajouté quelques modifications pour la rendre plus facile à utiliser. Voir les liens dans ma réponse pour plus d'info, mais l'idée sous-jacente est à partir de cette super réponse!
    • Pourquoi ce n'est pas la réponse sommet, déjà?
    • Malheureusement, avec NUnit 3, la source de TestCaseSource doit être statique, ce qui empêche l'utilisation d'un motif. La poisse.
    • Je ne vois pas quelle différence de ce qui rend la méthode statique ou pas. Le test de retour de l'ordre dans les deux sens.
    • Ce n'est pas la méthode qui doit être statique - la source (variable ou une propriété) de TestCaseSource doit être un objet statique dans NUnit 3, ou les tests ne seront pas exécutés. Et vous ne pouvez pas créer des objets dynamiques à l'intérieur d'un objet statique. C'est pourquoi il ne fonctionne pas dans la v. 3.
    • Vous avez essayé? Fonctionne pour moi github.com/DaveMBush/NUnit3Samples/blob/master/NUnit3Samples/...
    • Mon erreur - j'ai oublier de faire la classe vars static. Quand je fais ça, tout fonctionne bien.

    InformationsquelleAutor Dave Bush
  9. 5

    Je suis en train de travailler avec Selenium WebDriver de bout en bout de l'INTERFACE utilisateur des cas de test écrit en C#, qui sont exécutées à l'aide NUnit cadre. (Pas d'unité d'affaires)

    Ces tests de l'INTERFACE utilisateur certainement dépendre de l'ordre d'exécution, comme d'autres test doit ajouter certaines données comme une condition préalable. (Il n'est pas possible de faire les étapes dans tous les tests)

    Maintenant, après l'ajout de la 10e cas de test, je vois NUnit veut courir dans cet ordre:
    Test_1
    Test_10
    Test_2
    Test_3
    ..

    Donc je suppose que j'ai trop alphabetisize le test des noms de cas pour l'instant, mais il serait bon d'avoir cette petite fonctionnalité de contrôle de l'exécution de l'ordre ajouté à NUnit.

    • En désaccord d'Arran : UI tests sont par nature des séquences de petites étapes. Chaque étape devrait être un test (à Raison - si elle échoue, j'ai besoin de savoir qui de l'étape) . Les séquences peuvent être indépendants, mais à l'intérieur d'une séquence, l'ordre des questions & stop sur l'échec est nécessaire.
    InformationsquelleAutor Hexa
  10. 3

    Généralement de Test Unitaire doit être indépendant, mais si vous devez, ensuite, vous pouvez nommer vos méthodes dans l'ordre alphabétique ex:

    [Test]
public void Add_Users(){}
[Test]
public void Add_UsersB(){}
[Test]
public void Process_Users(){}

    ou vous pouvez le faire..

            private void Add_Users(){}
private void Add_UsersB(){}
[Test]
public void Process_Users()
{
Add_Users();
Add_UsersB();
//more code
}
    • Sauf que maintenant les noms doivent être faites alphabétique, ce qui est un affreux solutions. 🙁
    • non, il n'est pas terrible. Il fonctionne et dépend du comportement documenté de NUnit.
    • ➕1 assez bon pour moi, beaucoup plus facile si vous commencez vos tests avec a_ b_ t1_, t2_ à la place ou en s'appuyant sur facile de rater des caractères de fin
    InformationsquelleAutor Sebastian Castaldi
  11. 3

    Il y a de très bonnes raisons d'utiliser un Test mécanisme de traitement des commandes. La plupart de mes propres tests, utiliser de bonnes pratiques telles que l'installation/démontage. D'autres nécessitent d'énormes quantités de données de configuration, qui peut ensuite être utilisé pour tester une gamme de fonctionnalités. Jusqu'à présent, j'ai utilisé les gros tests pour gérer ces (Selenium Webdriver) tests d'intégration. Cependant, je pense que le ci-dessus suggère de poster sur https://github.com/nunit/docs/wiki/Order-Attribute a beaucoup de mérite. Voici un exemple de pourquoi la commande serait extrêmement précieux:

    • Utilisant Selenium Webdriver d'exécuter un test pour télécharger un rapport
    • L'état du rapport (si il est téléchargeable ou non) est mis en cache pour 10 minutes
    • Cela signifie que, avant chaque test, j'ai besoin de réinitialiser le rapport de l'état et attendez jusqu'à 10 minutes avant que l'état est confirmé avoir changé, et puis vérifier le rapport de téléchargements correctement.
    • Les rapports ne peuvent pas être générés dans une pratique /temps opportun par le biais de moqueries ou de tout autre mécanisme à l'intérieur du framework de test en raison de leur complexité.

    Cette 10 minutes d'attente le temps ralentit la suite de test. Quand vous multipliez similaires de mise en cache retards à travers une multitude de tests, il consomme beaucoup de temps. La commande de tests pourrait permettre de données de configuration à faire un "Test" dès le début de la suite de test, avec des tests en s'appuyant sur le cache de buste exécuté vers la fin de l'essai.

    InformationsquelleAutor user2986256
  12. 2

    Cette question est vraiment vieux maintenant, mais pour les gens qui peut atteindre cette fin de recherche, j'ai pris les excellentes réponses de user3275462 et PvtVandals /Rico et les a ajoutés à un GitHub avec certains de mes propres mises à jour. J'ai également créé associé à un blog avec quelques informations supplémentaires que vous pouvez regarder pour plus d'infos.

    Espère que cela est utile pour vous tous. Aussi, j'ai souvent envie d'utiliser l'attribut de Catégorie pour différencier mes tests d'intégration ou de l'autre de bout en bout de tests à partir de mes tests unitaires. D'autres ont souligné que les tests unitaires ne doivent pas avoir un ordre de dépendance, mais d'autres types de tests souvent, donc, cela donne une belle façon d'exécuter uniquement la catégorie de tests que vous voulez et aussi l'ordre de ceux de bout en bout tests.

    InformationsquelleAutor Chrispy
  13. 1

    Je suis un peu surpris de la NUnit communauté n'a pas trouver quoi que ce soit, je suis donc allé à créer quelque chose de moi-même.

    Je suis actuellement développement d'une bibliothèque libre qui vous permet de commander vos tests avec NUnit. Vous pouvez commander des appareils de test et de commande "ordonné spécifications de test" comme.

    La bibliothèque offre les fonctionnalités suivantes:

    • Construire des complexes de test de la commande hiérarchies
    • Passez les tests ultérieurs si un test dans le but d'échec
    • Ordre de vos méthodes de test de dépendance à la place de l'entier afin
    • Prend en charge l'utilisation side-by-side avec non ordonnée des tests. Non ordonnée tests sont exécutés en premier.

    La bibliothèque est en fait inspiré de la façon dont MSTest ne test de la commande auprès de .orderedtest fichiers. S'il vous plaît regardez l'exemple ci-dessous.

    [OrderedTestFixture]
public sealed class MyOrderedTestFixture : TestOrderingSpecification {
protected override void DefineTestOrdering() {
TestFixture<Fixture1>();
OrderedTestSpecification<MyOtherOrderedTestFixture>();
TestFixture<Fixture2>();
TestFixture<Fixture3>();
}
protected override bool ContinueOnError => false; //Or true, if you want to continue even if a child test fails
}
    InformationsquelleAutor Sebazzz
  14. 0

    Vous ne devrait pas dépendre de l'ordre dans lequel le framework de test choisit tests pour l'exécution. Les Tests doivent être isolés et indépendants. En ce qu'ils ne devraient pas dépendre des autres test de mise en scène pour eux ou nettoyage après eux. Ils doivent également produire le même résultat indépendamment de l'ordre d'exécution de tests (pour un aperçu de la CUS)

    J'ai fait un peu de recherche sur google. Comme d'habitude, certaines personnes ont eu recours à des astuces sournois (au lieu de résoudre le sous-jacent de testabilité/problème de conception de la

    • de nommer les tests un par ordre alphabétique, de telle manière que les tests s'affichent dans l'ordre de leur "besoin" d'être exécuté. Cependant NUnit peut choisir de modifier ce comportement avec une version ultérieure et puis vos tests serait arrosé. Amélioration de la vérification dans le courant de NUnit binaires de Contrôle de code Source.
    • VS (à mon humble avis encourageant le mauvais comportement avec leurs "outils agile") a quelque chose appelé "Commandé des tests" dans leur MS framework de test. Je n'ai pas perdu de temps à lire, mais il semble être destinée au même public

    Voir Aussi: caractéristiques d'un bon test

    • Il y a des occasions où vous voulez accélérer l'exécution de tests à exécuter avant longtemps, l'exécution des tests, plus précisément dans l'intégration et les tests d'acceptation. Par exemple, dans une application de blogs: vous testez la connexion d'abord, parce que si cela ne fonctionne pas, l'affichage ne fonctionne pas, soit il n'ya donc pas de point dans l'exécution de ce test (vous pouvez arrêter le coureur manuellement). Mais si vous essayez de garder à l'exécution de tests, puis il va prendre plus de temps.
    • vous pouvez atteindre cet objectif par le partitionnement de votre tests, soit par l'intermédiaire de différents physiques dll ou à l'aide de tags/catégories. Vous pouvez créer vos scripts à exécuter dll/catégories dans l'ordre. En général, permettant la commande de tests entraîne généralement couplé tests de développer des dépendances sur les voisins tests (sur le temps de cours). AFAIR dans la prochaine grande version de NUnit, il va prendre en charge différents de la commande de tests, par exemple aléatoire etc.
    • Partitionnement plus le même type de tests (tests d'acceptation, par exemple) n'a pas de sens, et de les séparer en une autre DLL augmente inutilement la complexité partout: le code source, des scripts, des scripts de test, la structure du projet, etc. Juste pour faire une simple réorganisation des tests.
    • Électroluminescentes(donc, fondamentalement, tous les moqueries libs) sont une raison pourquoi l'ordre est important. Vous ne pouvez pas décharger votre domaine d'application, et la nunit runner(si l'exécution de tous les tests dans une assemblée) conserve ce domaine pour tous les tests, à moins que "fixure'. Si un test crée un types pour tester quelque chose, et un autre test en conflit avec celle créée type, en raison de l'ordre, qui n'est pas un mauvais test. Ils sont isolés logiquement, c'est juste que nUnit ne pas offrir une bonne isolation entre chaque "test" lui-même.
    • À mon humble avis c'est un mauvais test, car il ne quitte pas le terrain comme il l'a trouvé. Vous pouvez avoir certaines contraintes dans "votre situation", mais pour le cas général, le conseil s'applique - tests doivent être isolés et, partant, de l'ordre agnostique.
    • Malheureusement, il ya certaines choses que vous ne pouvez pas nettoyer.
    • C'est assez condescendante de réponse, cela fait drôle parce que c'est vraiment s'appliquent uniquement aux tests unitaires et ignore complètement en étant pragmatique.
    • Rien ne vous empêche d'écrire de tels tests - toutefois, il ne de créer beaucoup de problèmes potentiels - par exemple cachés de l'installation ou de nettoyage (par exemple en supprimant un test à partir de la séquence bousille le reste). Vous ne pouvez pas accélérer ces suites de tests par exemple, l'exécution de chaque test sur une autre machine. La dépendance actuelle de l'outil de comportement qui pourrait changer. En essence, c'est juste un machin amorphe composée de plusieurs (éventuellement entrelacées) physique tests Nunit. Pourrait tout aussi bien comprimer dans un GRAND test
    • bla bla bla. si vous suivez ce comportement comme une pratique standard? non, bien sûr que non. Êtes-vous vraiment tester séquencé itération où des affaires de l'état et ce qui rend votre vie beaucoup mieux? assurez-vous d'aller de l'avant.
    • Les tests unitaires, par définition, des tests d'unités. Chaque unité est par définition unitaire, atomique et indépendante du reste. Séquentielle des essais, des tests d'intégration ou de tests d'acceptation où ce principe n'est pas suivie n'est pas de tests unitaires. La question est précisément de parler de NUnit, un cadre conçu pour unité de test, et comment tourner en quelque chose qu'il ne l'est pas. Si cette réponse est correcte, pas condescendant. Pour faire ce que vous voulez faire, vous avez besoin d'un autre cadre ou vous devez construire quelque chose sur le dessus de NUnit parce que NUnit est seulement pour les tests unitaires.

    InformationsquelleAutor Gishu
  15. 0

    Si vous utilisez [TestCase], l'argument TestName fournit un nom pour le test.

    Si non spécifié, le nom est généré en fonction du nom de la méthode et les arguments fournis.

    Vous pouvez contrôler l'ordre d'exécution de test comme indiqué ci-dessous:

                        [Test]
[TestCase("value1", TestName = "ExpressionTest_1")]
[TestCase("value2", TestName = "ExpressionTest_2")]
[TestCase("value3", TestName = "ExpressionTest_3")]
public void ExpressionTest(string  v)
{
//do your stuff
}

    Ici, j'ai utilisé le nom de la méthode "ExpressionTest" suffixe avec un nombre.

    Vous pouvez utiliser des noms commandé alphabétique
    voir Cas De Test D'Attribut

    InformationsquelleAutor M.Hassan
  16. 0

    Dans le cas de l'utilisation TestCaseSource la clé est de override string ToString méthode, Comment ça fonctionne:

    Suppose que vous avez des cas de test de la classe

    public class TestCase
{
public string Name { get; set; }
public int Input { get; set; }
public int Expected { get; set; }
}

    Et une liste de cas de tests:

    private static IEnumerable<TestCase> TestSource()
{
return new List<TestCase>
{
new TestCase()
{
Name = "Test 1",
Input = 2,
Expected = 4
},
new TestCase()
{
Name = "Test 2",
Input = 4,
Expected = 16
},
new TestCase()
{
Name = "Test 3",
Input = 10,
Expected = 100
}
};
}

    Maintenant permet de l'utiliser avec la méthode de Test et de voir ce qu'il se passe:

    [TestCaseSource(nameof(TestSource))]
public void MethodXTest(TestCase testCase)
{
var x = Power(testCase.Input);
x.ShouldBe(testCase.Expected);
}

    Ce ne sera pas le test dans l'ordre et la sortie sera comme ceci:

    NUnit Tester L'Exécution De L'Ordre

    Donc, si nous avons ajouté override string ToString de notre classe comme:

    public class TestCase
{
public string Name { get; set; }
public int Input { get; set; }
public int Expected { get; set; }
public override string ToString()
{
return Name;
}
}

    Le résultat va changer et nous obtenons l'ordre et le nom de test comme:

    NUnit Tester L'Exécution De L'Ordre

    Remarque:

    1. C'est juste pour illustrer comment obtenir le nom de l'ordre et de la tester, de la prise de commande numérique/alphabétique donc, si vous avez plus de dix test je suggère de faire le Test 01, Test 02.... Test 10, Test 11, etc, car si vous faites le Test 1 et le Test 10 de la commande sera le Test 1, Test 10, Test 2 .. etc.
    2. L'entrée et Attend peut être de tout type, string, objet ou d'une classe personnalisée.
    3. À côté de l'ordre, la bonne chose ici est que vous voyez le nom du test qui est le plus important.
    InformationsquelleAutor maytham-ɯɐɥʇʎɐɯ