c# - 验证单元测试中 [无序] 集合/项目集的完整映射

Question

我正在使用 xUnit.net、AutoFixture 和 SemanticComparison，并且想要验证映射的结果。

在单个项目级别，我很好地涵盖了。

给定

• 这些项目共享一个识别密钥
• 我想对两边的值元素做一个比较
• 我不在乎订购（并且不希望我的断言在重新订购时中断）

如何使用尽可能多的 OOTB 组件验证每个输入项是否以DAMP 但 DRY 方式映射到一个且只有一个输出项？

夹具：

class Input
{ 
   public string Name, Description;
}

class Output
{ 
   public string Name, Description, IgnoreThisField;
}

骨架测试：

[Theory,AutoData]
void MappingWorks( Mapper sut, Input[] inputs)
{
    var outputs = sut.Map( inputs);

    // TODO assert that every input is mapped
    // TODO assert that we have have no extra outputs
}

Answer 1

给定一个[非常简洁的] FullOuterJoin 操作和 xUnit.net V2，您可以将其表示为：

static void VerifyFeaturesetFullyMapped(
    IEnumerable<Output> outputs,
    IEnumerable<Input> inputs )
{
    Assert.All(
        inputs.FullOuterJoin( outputs,
            f => f.Item1, r => r.Name,
            ( x, y, key ) => new { 
                InDescription = x.Item2, 
                OutDescription = y.Description } ),
        inout =>
            Assert.Equal( inout.InDescription, inout.OutDescription ) );
}

Answer 2

给定一些AssertResemblance.Like集合助手[1]，你

1. 将它们按相同的顺序排列（这是在测试主体中最干净地完成的，因为输入和输出集合将是不同的类型，除非SemanticComparison增加一个特性，否则我认为它不能被有用地概括）
2. 让Ploeh.SemanticComparison我们Likeness在Name
3. 让 xUnit.net V2 的 Assert.Collection 进行关联（它还没有给出更重要的信息）

最终结果是：

var results = from result in outputs orderby result.Name select result;

var expectations = from input in inputs orderby input.Name select input;
AssertResemblance.Like( expectations, results, 
   configure=>configure
      .Without(x=>x.IgnoreThisField) );

---

[1]

static class AssertResemblance
{
    public static void Like<T, T2>( IEnumerable<T> expected, IEnumerable<T2> actual )
    {
        Like<T, T2>( expected, actual, x=>x );
    }

    public static void Like<T, T2>( IEnumerable<T> expected, IEnumerable<T2> actual, Func<Likeness<T, T2>, Likeness<T, T2>> configureLikeness )
    {
        Assert2.Collection( actual, SelectShouldEqualAsAction( expected.Select( x => configureLikeness( x.AsSource().OfLikeness<T2>() ) ) ) );
    }

    public static void Like<T>( IEnumerable<T> expected, IEnumerable<T> actual, Func<IEnumerable<T>, IEnumerable<T>> unify )
    {
        Like<T>( expected, actual, unify, x=>x );
    }

    public static void Like<T>( IEnumerable<T> expected, IEnumerable<T> actual, Func<IEnumerable<T>,IEnumerable<T>> unify, Func<Likeness<T, T>, Likeness<T, T>> configureLikeness )
    {
        Assert2.Collection( unify( actual ), SelectShouldEqualAsAction( unify(expected).Select( x => configureLikeness( x.AsSource().OfLikeness<T>() ) ) ) );
    }

    static Action<TDestination>[] SelectShouldEqualAsAction<TSource, TDestination>( IEnumerable<Likeness<TSource, TDestination>> that )
    {
        return (from it in that select (Action<TDestination>)it.ShouldEqual).ToArray();
    }
}