Parametryzacja testu w xUnit.net podobne do NUnit

Pozwól, że rzucę jeszcze jedną próbkę, na wypadek, gdyby to komuś oszczędziło trochę czasu.

[Theory]
[InlineData("goodnight moon", "moon", true)]
[InlineData("hello world", "hi", false)]
public void Contains(string input, string sub, bool expected)
{
    var actual = input.Contains(sub);
    Assert.Equal(expected, actual);
}

Na pierwsze życzenie możesz skorzystać z przykładów znalezionych tutaj .

Możesz skonstruować statyczną klasę zawierającą dane niezbędne do zbioru testów

using System.Collections.Generic;

namespace PropertyDataDrivenTests
{
    public static class DemoPropertyDataSource
    {
        private static readonly List<object[]> _data = new List<object[]>
            {
                new object[] {1, true},
                new object[] {2, false},
                new object[] {-1, false},
                new object[] {0, false}
            };

        public static IEnumerable<object[]> TestData
        {
            get { return _data; }
        }
    }
}

Następnie, używając atrybutu Memdata, zdefiniuj test jako taki

public class TestFile1
{
    [Theory]
    [MemberData("TestData", MemberType = typeof(DemoPropertyDataSource))]
    public void SampleTest1(int number, bool expectedResult)
    {
        var sut = new CheckThisNumber(1);
        var result = sut.CheckIfEqual(number);
        Assert.Equal(result, expectedResult);
    }
}

Lub jeśli używasz C # 6.0,

[Theory]
[MemberData(nameof(PropertyDataDrivenTests.TestData), MemberType = typeof(DemoPropertyDataSource))]

Pierwszy argument MemberDataAttribute pozwala ci zdefiniować członka, którego używasz jako źródła danych, więc masz dużą elastyczność w ponownym użyciu.

Zgodnie z Ten artykuł {[5] } w xUnit masz trzy opcje "parametryzacji":

1. InlineData
2. ClassData
3. MemberData

Przykład InlineData

[Theory]
[InlineData(1, 2)]
[InlineData(-4, -6)]
[InlineData(2, 4)]
public void FooTest(int value1, int value2)
{
    Assert.True(value1 + value2 < 7)
}

Przykład ClassData

public class BarTestData : IEnumerable<object[]>
{
    public IEnumerator<object[]> GetEnumerator()
    {
        yield return new object[] { 1, 2 };
        yield return new object[] { -4, -6 };
        yield return new object[] { 2, 4 };
    }

    IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
}


[Theory]
[ClassData(typeof(BarTestData))]
public void BarTest(int value1, int value2)
{
    Assert.True(value1 + value2 < 7)
}

Przykład MemberData

[Theory]
[MemberData(nameof(BazTestData))]
public void BazTest(int value1, int value2)
{
    Assert.True(value1 + value2 < 7)
}

public static IEnumerable<object[]> BazTestData => new List<object[]>
    {
        new object[] { 1, 2 },
        new object[] { -4, -6 },
        new object[] { 2, 4 },
    };

Znalazłem bibliotekę, która generuje podobną funkcjonalność do atrybutu [Values] NUnit o nazwie Xunit.Kombinatoryczne :

Pozwala na określenie wartości poziomu parametrów:

[Theory, CombinatorialData]
public void CheckValidAge([CombinatorialValues(5, 18, 21, 25)] int age, 
    bool friendlyOfficer)
{
    // This will run with all combinations:
    // 5  true
    // 18 true
    // 21 true
    // 25 true
    // 5  false
    // 18 false
    // 21 false
    // 25 false
}

Lub możesz w domyśle ustalić minimalną liczbę wywołań, aby pokryć wszystkie możliwe kombinacje:

[Theory, PairwiseData]
public void CheckValidAge(bool p1, bool p2, bool p3)
{
    // Pairwise generates these 4 test cases:
    // false false false
    // false true  true
    // true  false true
    // true  true  false
}

Wzięłam na pokład wszystkie odpowiedzi tutaj i dodatkowo skorzystałam z typów generycznych XUnit TheoryData<,>, aby dać mi proste, łatwe do odczytania i wpisz bezpieczne definicje danych dla atrybutu 'MemberData' w moim teście, jak na poniższym przykładzie:

/// must be public & static for MemberDataAttr to use
public static TheoryData<int, bool, string> DataForTest1 = new TheoryData<int, bool, string> {
    { 1, true, "First" },
    { 2, false, "Second" },
    { 3, true, "Third" }
};

[Theory(DisplayName = "My First Test"), MemberData(nameof(DataForTest1))]
public void Test1(int valA, bool valB, string valC)
{
    Debug.WriteLine($"Running {nameof(Test1)} with values: {valA}, {valB} & {valC} ");
}