奇数Xunit测试

Question

我正在努力提高我的单元测试技能，我想知道是否有人能告诉我编写测试的最佳方法，以编写“给定整数数组的排序奇数”的测试。 目前，我正在用params将数据传递到测试中，但我也要验证输出是否正确。

    [Theory]
    [InlineData(1,2,3,4)]
    public void SortArrayOddNumber(params int[] number)
    {
        var s = number.Where(n => (n % 2) == 0).OrderBy(n=>n);
    }

Answer 1

你并不是真的在写单元测试。 您在测试中编写了一些代码，并希望对其进行验证。 通常情况下，您在其他地方会有一个方法，您正在尝试验证该方法。 让我们假设你有:

public static Numbers
{
   public static IEnumerable<int> FilterAndSortOdds(IEnumerable<int> source) 
       => source.Where(i => (i%2) != 0).OrderBy(i => i);
}

然后验证从测试中调用该方法。 例如，简单的fact可能如下所示:

public class TestClass
{

    [Fact]
    public void CanSortAndFilterOddNumbers() 
    { 
       var source = new[] { 1, 2, 9, 4, 5 };
       var expected = new[] { 1, 5, 9 };
    
       var actual = Numbers.FilterAndSortOdds(source).ToArray();
       Assert.Equal(expected, actual);
    } 

}

如果你想把这个转化为一个理论，你有几个选择。 您可以使用inlineData（通过创建新数组）

public class TestClass
{
    [Theory]
    [InlineData(new[] { 1, 2, 9, 4, 5 }, new[] { 1, 5, 9 })] 
    [InlineData(new[] { 2, 1 }, new[] { 1 })] 
    [InlineData(new[] { 9, 7, 5, 3, 1 }, new[] { 1, 3, 5, 7, 9 })] 
    public void CanSortAndFilterOddNumbers(int[] source, int[] expected) 
    { 
       var actual = Numbers.FilterAndSortOdds(source).ToArray();
       Assert.Equal(expected, actual);
    } 

您还可以使用MemberData:

public class TestClass
{
    [Theory]
    [MemberData(nameof(PassingData)] 
    public void CanSortAndFilterOddNumbers(int[] source, int[] expected) 
    { 
       var actual = Numbers.FilterAndSortOdds(source).ToArray();
       Assert.Equal(expected, actual);
    } 

    public static IEnumerable<object[]> PassingData => new List<object[]> {
         /* Test 1 */
         new object[] { new[] { 1, 2, 9, 4, 5 }, new[] { 1, 5, 9 } }, 
        /* Test 2 */
         new object[] { new[] { 2, 1 }, new[] { 1 } }, 
        /* Test 3 */
         new object[] { new[] { 9, 7, 5, 3, 1 }, new[] { 1, 3, 5, 7, 9 } }
   };
}

对于类型更强一点的内容，我们可以使用classdata和theorydata助手:

public class TestClass
{
    [Theory]
    [ClassData(nameof(PassingOdds)] 
    public void CanSortAndFilterOddNumbers(IEnumerable<int> source, int[] expected) 
    { 
       var actual = Numbers.FilterAndSortOdds(source).ToArray();
       Assert.Equal(expected, actual);
    } 
}

public class PassingOdds : 
    TheoryData</*arg1*/IEnumerable<int>, /*arg2*/int[]>
{
    public PassingOdds()
    {
         /* Test 1*/
         Add(new[] { 1, 2, 9, 4, 5 }, new[] { 1, 5, 9 });
         /* Test 2 */
         Add(new List<int> { 2, 1 }, new[] { 1 });
         /* Test 3 */
         Add(new[] { 9, 7, 5, 3, 1 }, new[] { 1, 3, 5, 7, 9 });
    } 
} 

ClassData也可以用于类似于MemberData的非泛型（基于IEnumerable 的）模型中。 Andrew Lock在这个主题上有几篇很棒的博客文章。 您还可以在github上的xUnit示例中看到这一点。

Answer 2

首先，您正在编写测试内部的逻辑。

您希望测试一个单独的类。

第二，你会在哪里通过预期的结果？

你可以找到一种方法将多个数据传递给你的测试，就像Arsalan在他的回答中所说的那样，或者你的断言应该检查所有的数字都是奇数，并且它们是按升序排列的。

您可以查看FluentAssertions库，并按如下方式编写测试:

// The class/method you are testing
public class MyLogic
{
  public int[] SortOddNumbers(int[] input)
  {
    return input.Where(n => (n%2) == 1).OrderBy(n => n).ToArray();
  }
}

和测试:

public class MyLogic.Tests
{

  [Theory]
  [InlineData(6,1,2,3,10,9,8)]
  public void SortOddNumbers_ShouldReturn_OddNumbersInAscendingOrder(params int[] input)
  {
    // Arrange
    var logic = new MyLogic();
    // Act
    var actual = logic.SortOddNumbers(input);
    // Assert
    actual.Should().OnlyContain(x => x % 2 == 1);
    actual.Should().BeInAscendingOrder(x => x);
  }
}

编辑:为了找到如何将数据传递给测试的多种方法（和灵感），下面是Andrew Lock的一篇优秀文章:https://andrewlock.net/creating-parameterised-tests-in-xunit-with-inlinedata-classdata-and-memberdata/

Answer 3

您应该在测试中传递输入数组和预期数组作为参数。

您可以使用InlineData，如下所示:

    [Theory]
    [InlineData(new[] { 0, 1, 2, 3, 4 }, new[] { 0, 2, 4 })]
    [InlineData(new[] { 0, 1, 3, 4 }, new[] { 0, 4 })]
    public void Should_return_odd_numbers_in_ascending_order(int[] input, int[] expectedSortedArray)
    {
        var result = input.SortOddNumbers();

        result.Should().BeEquivalentTo(expectedSortedArray, opt => opt.WithStrictOrdering());
    }

或者您可以像这样使用MemberData:

    public static IEnumerable<object[]> Data => new List<object[]>
    {
       new object[] {new[] {0, 1, 2, 3, 4}, new[] {0, 2, 4}},
       new object[] {new[] {0, 1, 3, 4}, new[] {0, 4}}
    };

    [Theory, MemberData(nameof(Data))]
    public void Should_return_odd_numbers_in_ascending_order(int[] input, int[] expectedSortedArray)
    {
        var result = input.SortOddNumbers();

        result.Should().BeEquivalentTo(expectedSortedArray, opt => opt.WithStrictOrdering());
    }

和SortOddNumbers扩展方法:

public static class NumberExtensions
{
    public static int[] SortOddNumbers(this int[] input)
    {
        return input.Where(i => (i % 2) == 0).OrderBy(i => i).ToArray();
    }
}