如何在xUnit中设置测试用例序列

在xUnit 2.*中，这可以使用TestCaseOrderer属性来指定排序策略，该策略可以用于引用在每个测试上注释的属性来表示顺序。

例如：

订购策略

[assembly: CollectionBehavior(DisableTestParallelization = true)] 
public class PriorityOrderer : ITestCaseOrderer
{
    public IEnumerable<TTestCase> OrderTestCases<TTestCase>(IEnumerable<TTestCase> testCases) where TTestCase : ITestCase
    {
        var sortedMethods = new SortedDictionary<int, List<TTestCase>>();
        foreach (TTestCase testCase in testCases)
        {
            int priority = 0;
            foreach (IAttributeInfo attr in testCase.TestMethod.Method.GetCustomAttributes((typeof(TestPriorityAttribute).AssemblyQualifiedName)))
                priority = attr.GetNamedArgument<int>("Priority");
            GetOrCreate(sortedMethods, priority).Add(testCase);
        }
        foreach (var list in sortedMethods.Keys.Select(priority => sortedMethods[priority]))
        {
            list.Sort((x, y) => StringComparer.OrdinalIgnoreCase.Compare(x.TestMethod.Method.Name, y.TestMethod.Method.Name));
            foreach (TTestCase testCase in list)
                yield return testCase;
        }
    }
    static TValue GetOrCreate<TKey, TValue>(IDictionary<TKey, TValue> dictionary, TKey key) where TValue : new()
    {
        TValue result;
        if (dictionary.TryGetValue(key, out result)) return result;
        result = new TValue();
        dictionary[key] = result;
        return result;
    }
}

属性

[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
public class TestPriorityAttribute : Attribute
{
    public TestPriorityAttribute(int priority)
    {
        Priority = priority;
    }
    public int Priority { get; private set; }
}

测试用例

[TestCaseOrderer("FullNameOfOrderStrategyHere", "OrderStrategyAssemblyName")]
public class PriorityOrderExamples
{
    [Fact, TestPriority(5)]
    public void Test3()
    {
        // called third
    }
    [Fact, TestPriority(0)]
    public void Test2()
    {
      // called second
    }
    [Fact, TestPriority(-5)]
    public void Test1()
    {
       // called first
    }
}

xUnit2.*在此处订购样品

Testpriority:位于本页底部。

[PrioritizedFixture]
public class MyTests
{
    [Fact, TestPriority(1)]
    public void FirstTest()
    {
        // Test code here is always run first
    }
    [Fact, TestPriority(2)]
    public void SeccondTest()
    {
        // Test code here is run second
    }
}

顺便说一句，我现在也有同样的问题。是的，这不是一门干净的艺术……但QA想要一个手动测试。。因此，一个特定订单的自动化测试对他们来说已经是一个巨大的飞跃。。（咳嗽）是的，这并不是真正的单元测试。。

如果您确实需要对测试（可能不是单元测试）进行优先级排序，则可以使用Xuit.Priority。我已经将其用于一些集成测试，并且工作非常好且简单，无需编写优先级排序类的开销，适用于简单的案例场景

由于某些原因，XUnit.Priority对我不起作用。在我的测试用例中，它没有按照指定的优先级顺序运行测试。

因此，我尝试了XUnitPriorityOrderer，它与使用类似，但正在运行（为了快速测试它，请将以下代码保存在文本编辑器中作为OrderedXUnitTests.linq，然后用LinqPad 6打开它并执行它。或者，您也可以将TestClass复制到Visual Studio，并添加XUnit、XUnit.Runner.VisualStudio和XUnitPriorityOrderer）：

<Query Kind="Program">
  <NuGetReference>XUnitPriorityOrderer</NuGetReference>
  <Namespace>Xunit</Namespace>
  <Namespace>XUnitPriorityOrderer</Namespace>
</Query>

#load "xunit"
// using XUnitPriorityOrderer
// see: https://github.com/frederic-prusse/XUnitPriorityOrderer
void Main()
{
    RunTests();  // Call RunTests() or press Alt+Shift+T to initiate testing.
}

#region private::Tests
[TestCaseOrderer(CasePriorityOrderer.TypeName, CasePriorityOrderer.AssembyName)]
public class TestClass
{
    static List<string> Order { get; set; }
    
    public TestClass()
    {
        Order = Order ?? new List<string>();
    }
    [Fact, Order(2)]
    void Test_Xunit_AnotherTest()
    {
        Order.Add("Test_Xunit_AnotherTest");
        Assert.True(3 + 1 == 4);
    }
    [Fact, Order(1)]
    void Test_Xunit()
    {
        Order.Add("Test_XUnit");
        Assert.True(1 + 1 == 2);
    }
    [Fact, Order(99)]
    void Print_Order()
    {
        Order.Add("Print_Order");
        var strOrder = string.Join(", ", Order.ToArray());
        strOrder.Dump("Execution Order");
        Assert.True(true);
    }
}
#endregion

这将按照给定的顺序（顺序（1）、顺序（2）和顺序（99））运行测试，并最终转储执行的测试（测试方法Print_order（））。

根据设计，你不能。它是故意随机的，以防止任何人因欲望或意外而得到其中一个。

随机性只适用于给定的Test类，因此您可以通过将要控制其顺序的项包装在嵌套类中来实现目标，但在这种情况下，只要类中有两个以上的Test方法，您仍然会以随机顺序结束。

如果您试图管理固定装置或上下文的构建，那么内置的IUseFixture<T>机制可能是合适的。有关示例，请参阅xUnit备忘单。

但你真的需要告诉我们更多你想做什么，否则我们只能猜测。