Ordre d'exécution du test NUnit

Question

Par défaut, les tests nunit se déroulent par ordre alphabétique. Est-ce que quelqu'un connaît un moyen de définir l'ordre d'exécution? Un attribut existe-t-il pour cela?

Answer 1

Je tiens simplement à souligner que, si la plupart des répondants ont supposé qu'il s'agissait de tests unitaires, la question ne précisait pas qu'ils l'étaient.

nUnit est un excellent outil qui peut être utilisé pour diverses situations de test. Je peux voir les raisons appropriées pour vouloir contrôler la commande de test.

Dans ces situations, j'ai dû incorporer un ordre d'exécution au nom du test. Il serait bon de pouvoir spécifier l'ordre d'exécution à l'aide d'un attribut.

Answer 2

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 des 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.

Answer 3

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 affichés - 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

Answer 4

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"?

Answer 5

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

Je l'ai un peu modifié pour pouvoir utiliser un attribut pour définir la plage de commandes:

 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);
                }
            }

        }
    }
}
 

}