使用 xunit 編寫測試代碼

時間 2021-02-28

標籤 html git github 數據庫 c# mvc 框架 less ide 單元測試欄目 HTML 简体版

原文原文鏈接

使用 xunit 編寫測試代碼

Intro

xunit 是 .NET 裏使用很是普遍的一個測試框架，有不少測試項目都是在使用 xunit 做爲測試框架，不單單有不少開源項目在使用，不少微軟的項目也在使用 xunit 來做爲測試框架。html

Get Started

在 xunit 中不須要標記測試類，全部 public 的相似均可以做爲測試類，測試方法須要使用 Fact 或者 Theory 註解來標註方法，來看一個基本的使用示例：git

首先準備了幾個要測試的方法：github

internal class Helper
{
    public static int Add(int x, int y)
    {
        return x + y;
    }

    public static void ArgumentExceptionTest() => throw new ArgumentException();

    public static void ArgumentNullExceptionTest() => throw new ArgumentNullException();
}

測試代碼：數據庫

public class BasicTest
{
    [Fact]
    public void AddTest()
    {
        Assert.Equal(4, Helper.Add(2, 2));
        Assert.NotEqual(3, Helper.Add(2, 2));
    }

    [Theory]
    [InlineData(1, 2)]
    [InlineData(2, 2)]
    public void AddTestWithTestData(int num1, int num2)
    {
        Assert.Equal(num1 + num2, Helper.Add(num1, num2));
    }
}

使用 Fact 標記的測試方法不能有方法參數，只有標記 Theory 的方法能夠有方法參數c#

使用 Assert 來斷言結果是否符合預期，xunit 提供了很豐富的 Assert 方法，可使得咱們的測試代碼更加簡潔。mvc

Exception Assert框架

除了通常的結果斷言，xunit 也支持 exception 斷言，主要支持兩大類，Assert.Throw/Assert.Throw<TExceptionType>/Assert.ThrowAny<TExceptionType>，對應的也有 Async 版本less

[Fact]
public void ExceptionTest()
{
    var exceptionType = typeof(ArgumentException);
    Assert.Throws(exceptionType, Helper.ArgumentExceptionTest);
    Assert.Throws<ArgumentException>(testCode: Helper.ArgumentExceptionTest);
}

[Fact]
public void ExceptionAnyTest()
{
    Assert.Throws<ArgumentNullException>(Helper.ArgumentNullExceptionTest);
    Assert.ThrowsAny<ArgumentNullException>(Helper.ArgumentNullExceptionTest);
    Assert.ThrowsAny<ArgumentException>(Helper.ArgumentNullExceptionTest);
}

Assert.Throw(exceptionType, action) 和 Assert.Throw<TExceptionType>(action) 這樣的 exception 類型只能是這個類型，繼承於這個類型的不算，會 fail，而 Assert.ThrowAny<TExceptionType>(action) 則更包容一點，是這個類型或者是繼承於這個類型的均可以。ide

Comparisons

不少人已經在使用其餘的測試框架，如何遷移呢，xunit 也給出了與 nunit 和 mstest 的對比，詳細能夠參考下面的對比，具體能夠參考 https://xunit.net/docs/comparisons：單元測試

NUnit 3.x	MSTest 15.x	xUnit.net 2.x	Comments
`[Test]`	`[TestMethod]`	`[Fact]`	Marks a test method.
`[TestFixture]`	`[TestClass]`	n/a	xUnit.net does not require an attribute for a test class; it looks for all test methods in all public (exported) classes in the assembly.
`Assert.That` `Record.Exception`	`[ExpectedException]`	`Assert.Throws` `Record.Exception`	xUnit.net has done away with the ExpectedException attribute in favor of `Assert.Throws`. See Note 1
`[SetUp]`	`[TestInitialize]`	Constructor	We believe that use of `[SetUp]` is generally bad. However, you can implement a parameterless constructor as a direct replacement. See Note 2
`[TearDown]`	`[TestCleanup]`	`IDisposable.Dispose`	We believe that use of `[TearDown]` is generally bad. However, you can implement `IDisposable.Dispose` as a direct replacement. See Note 2
`[OneTimeSetUp]`	`[ClassInitialize]`	`IClassFixture<T>`	To get per-class fixture setup, implement `IClassFixture<T>` on your test class. See Note 3
`[OneTimeTearDown]`	`[ClassCleanup]`	`IClassFixture<T>`	To get per-class fixture teardown, implement `IClassFixture<T>` on your test class. See Note 3
n/a	n/a	`ICollectionFixture<T>`	To get per-collection fixture setup and teardown, implement `ICollectionFixture<T>` on your test collection. See Note 3
`[Ignore("reason")]`	`[Ignore]`	`[Fact(Skip="reason")]`	Set the Skip parameter on the `[Fact]` attribute to temporarily skip a test.
`[Property]`	`[TestProperty]`	`[Trait]`	Set arbitrary metadata on a test
`[Theory]`	`[DataSource]`	`[Theory]` `[XxxData]`	Theory (data-driven test). See Note 4

Data Driven Test

測試框架大多提供數據驅動測試的支持，簡單的就如開篇中的 Theory 示例，咱們再來看一些稍微複雜一些的示例，一塊兒來看下：

要使用數據驅動的方式寫測試方法，測試方法應該標記爲 Theory，而且將測試數據做爲測試方法的方法參數

`InlineData`

最基本數據驅動的方式當屬 InlineData，添加多個 InlineData 便可使用不一樣的測試數據進行測試

[Theory]
[InlineData(1)]
[InlineData(2)]
[InlineData(3)]
public void InlineDataTest(int num)
{
    Assert.True(num > 0);
}

InlineData 有其限制，只能使用一些常量，想要更靈活的方式須要使用別的方式，測試結果：

`MemberData`

MemberData 能夠必定程度上解決 InlineData 存在的問題，MemberData 支持字段、屬性或方法，且須要知足下面兩個條件：

須要是 public 的
須要是 static 的
能夠隱式轉換爲 IEnumerable<object[]> 或者方法返回值能夠隱式轉換爲 IEnumerable<object[]>

來看下面的示例：

[Theory]
[MemberData(nameof(TestMemberData))]
public void MemberDataPropertyTest(int num)
{
    Assert.True(num > 0);
}

public static IEnumerable<object[]> TestMemberData =>
    Enumerable.Range(1, 10)
        .Select(x => new object[] { x })
        .ToArray();

[Theory]
[MemberData(nameof(TestMemberDataField))]
public void MemberDataFieldTest(int num)
{
    Assert.True(num > 0);
}

public static readonly IList<object[]> TestMemberDataField = Enumerable.Range(1, 10).Select(x => new object[] { x }).ToArray();

[Theory]
[MemberData(nameof(TestMemberDataMethod), 10)]
public void MemberDataMethodTest(int num)
{
    Assert.True(num > 0);
}

public static IEnumerable<object[]> TestMemberDataMethod(int count)
{
    return Enumerable.Range(1, count).Select(i => new object[] { i });
}

測試結果：

Custom Data Source

MemberData 相比之下提供了更大的便利和可自定義程度，只能在當前測試類中使用，想要跨測試類仍是不行，xunit 還提供了 DataAttribute ，使得咱們能夠經過自定義方式實現測試方法數據源，甚至也能夠從數據庫裏動態查詢出數據，寫了一個簡單的示例，能夠參考下面的示例：

自定義數據源：

public class NullOrEmptyStringDataAttribute : DataAttribute
{
    public override IEnumerable<object[]> GetData(MethodInfo testMethod)
    {
        yield return new object[] { null };
        yield return new object[] { string.Empty };
    }
}

測試方法：

[Theory]
[NullOrEmptyStringData]
public void CustomDataAttributeTest(string value)
{
    Assert.True(string.IsNullOrEmpty(value));
}

測試結果：

Output

在測試方法中若是想要輸出一些測試信息，直接是用 Console.Write/Console.WriteLine 是沒有效果的，在測試方法中輸出須要使用 ITestoutputHelper 來輸出，來看下面的示例：

public class OutputTest
{
    private readonly ITestOutputHelper _outputHelper;

    public OutputTest(ITestOutputHelper outputHelper)
    {
        _outputHelper = outputHelper;
    }

    [Fact]
    public void ConsoleWriteTest()
    {
        Console.WriteLine("Console");
    }

    [Fact]
    public void OutputHelperTest()
    {
        _outputHelper.WriteLine("Output");
    }
}

測試方法中使用 Console.Write/Console.WriteLine 的時候會有一個提示：

測試輸出結果：

Test Filter

xunit 提供了 BeforeAfterTestAttribute 來讓咱們實現一些自定義的邏輯來在測試運行前和運行後執行，和 mvc 裏的 action filter 很像，因此這裏我把他稱爲 test filter，來看下面的一個示例，改編自 xunit 的示例：

/// <summary>
/// Apply this attribute to your test method to replace the
/// <see cref="Thread.CurrentThread" /> <see cref="CultureInfo.CurrentCulture" /> and
/// <see cref="CultureInfo.CurrentUICulture" /> with another culture.
/// </summary>
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public class UseCultureAttribute : BeforeAfterTestAttribute
{
    private readonly Lazy<CultureInfo> _culture;
    private readonly Lazy<CultureInfo> _uiCulture;

    private CultureInfo _originalCulture;
    private CultureInfo _originalUiCulture;

    /// <summary>
    /// Replaces the culture and UI culture of the current thread with
    /// <paramref name="culture" />
    /// </summary>
    /// <param name="culture">The name of the culture.</param>
    /// <remarks>
    /// <para>
    /// This constructor overload uses <paramref name="culture" /> for both
    /// <see cref="Culture" /> and <see cref="UICulture" />.
    /// </para>
    /// </remarks>
    public UseCultureAttribute(string culture)
        : this(culture, culture) { }

    /// <summary>
    /// Replaces the culture and UI culture of the current thread with
    /// <paramref name="culture" /> and <paramref name="uiCulture" />
    /// </summary>
    /// <param name="culture">The name of the culture.</param>
    /// <param name="uiCulture">The name of the UI culture.</param>
    public UseCultureAttribute(string culture, string uiCulture)
    {
        _culture = new Lazy<CultureInfo>(() => new CultureInfo(culture, false));
        _uiCulture = new Lazy<CultureInfo>(() => new CultureInfo(uiCulture, false));
    }

    /// <summary>
    /// Gets the culture.
    /// </summary>
    public CultureInfo Culture { get { return _culture.Value; } }

    /// <summary>
    /// Gets the UI culture.
    /// </summary>
    public CultureInfo UICulture { get { return _uiCulture.Value; } }

    /// <summary>
    /// Stores the current <see cref="Thread.CurrentPrincipal" />
    /// <see cref="CultureInfo.CurrentCulture" /> and <see cref="CultureInfo.CurrentUICulture" />
    /// and replaces them with the new cultures defined in the constructor.
    /// </summary>
    /// <param name="methodUnderTest">The method under test</param>
    public override void Before(MethodInfo methodUnderTest)
    {
        _originalCulture = Thread.CurrentThread.CurrentCulture;
        _originalUiCulture = Thread.CurrentThread.CurrentUICulture;

        Thread.CurrentThread.CurrentCulture = Culture;
        Thread.CurrentThread.CurrentUICulture = UICulture;

        CultureInfo.CurrentCulture.ClearCachedData();
        CultureInfo.CurrentUICulture.ClearCachedData();
    }

    /// <summary>
    /// Restores the original <see cref="CultureInfo.CurrentCulture" /> and
    /// <see cref="CultureInfo.CurrentUICulture" /> to <see cref="Thread.CurrentPrincipal" />
    /// </summary>
    /// <param name="methodUnderTest">The method under test</param>
    public override void After(MethodInfo methodUnderTest)
    {
        Thread.CurrentThread.CurrentCulture = _originalCulture;
        Thread.CurrentThread.CurrentUICulture = _originalUiCulture;

        CultureInfo.CurrentCulture.ClearCachedData();
        CultureInfo.CurrentUICulture.ClearCachedData();
    }
}

這裏實現了一個設置測試用例運行過程當中 Thread.CurrentThread.Culture 的屬性，測試結束後恢復原始的屬性值，能夠用做於 Class 也能夠用在測試方法中，使用示例以下：

[UseCulture("en-US", "zh-CN")]
public class FilterTest
{
    [Fact]
    [UseCulture("en-US")]
    public void CultureTest()
    {
        Assert.Equal("en-US", Thread.CurrentThread.CurrentCulture.Name);
    }

    [Fact]
    [UseCulture("zh-CN")]
    public void CultureTest2()
    {
        Assert.Equal("zh-CN", Thread.CurrentThread.CurrentCulture.Name);
    }

    [Fact]
    public void CultureTest3()
    {
        Assert.Equal("en-US", Thread.CurrentThread.CurrentCulture.Name);
        Assert.Equal("zh-CN", Thread.CurrentThread.CurrentUICulture.Name);
    }
}

測試結果以下：