使用 xunit 編寫測試程式碼
Intro
xunit 是 .NET 裡使用非常廣泛的一個測試框架，有很多測試專案都是在使用 xunit 作為測試框架，不僅僅有很多開源專案在使用，很多微軟的專案也在使用 xunit 來作為測試框架。
Get Started
在 xunit 中不需要標記測試類，所有 public 的類似都可以作為測試類，測試方法需要使用 Fact 或者 Theory 註解來標註方法，來看一個基本的使用示例：
首先準備了幾個要測試的方法：
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 的方法可以有方法引數
使用 Assert 來斷言結果是否符合預期，xunit 提供了很豐富的 Assert 方法，可以使得我們的測試程式碼更加簡潔。
Exception Assert
除了一般的結果斷言，xunit 也支援 exception 斷言，主要支援兩大類，Assert.Throw/Assert.Throw<TExceptionType>/Assert.ThrowAny<TExceptionType>，對應的也有 Async 版本
[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) 則更包容一點，是這個型別或者是繼承於這個型別的都可以。
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);
}
}
測試結果如下：
Shared Context
單元測試類通常共享初始化和清理程式碼（通常稱為“測試上下文”）。 xunit 提供了幾種共享初始化和清理程式碼程式碼的方法，具體取決於要共享的物件的範圍。
- 構造器和
Dispose方法 (共享初始化和 Dispose，不需要共享物件) - Class Fixtures (同一個測試類中共享物件)
- Collection Fixtures (同一個 Collection 中（可以是多個測試類）中共享物件例項)
通常我們可以使用 Fixture 來實現依賴注入，但是我更推薦使用 Xunit.DependencyInjection 這個專案來實現依賴注入，具體使用可以參考之前的文章 在 xunit 測試專案中使用依賴注入 中的介紹
More
希望對你使用 xunit 有所幫助
文章中的示例程式碼可以從 https://github.com/WeihanLi/SamplesInPractice/tree/master/XunitSample 獲取
xunit 還有很多可以擴充套件的地方，更多可以參考 xunit 的示例 https://github.com/xunit/samples.xunit