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

【问题标题】：Verifying complete Mapping of an [unordered] Collection/Set of Items in a Unit Test验证单元测试中 [无序] 集合/项目集的完整映射
【发布时间】：2013-05-24 21:26:08
【问题描述】：

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

On the individual item level, I'm well covered.

给定

项目共享一个识别键
我想对两边的value元素做个对比
我不关心订购（并且不希望我的断言在重新订购时中断）

如何使用尽可能多的 OOTB 组件验证每个输入项是否映射到 DAMP yet DRY manner 中的一个且仅一个输出项？

夹具：

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
}

【问题讨论】：

标签： c# unit-testing xunit.net semantic-comparison

【解决方案1】：

给定一个[very neat] FullOuterJoin operation 和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 ) );
}

【讨论】：

【解决方案2】：

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

将它们按相同的顺序排列（这在测试主体中完成得最干净，因为输入和输出集合将是不同的类型，除非SemanticComparison 增加了一个我认为无法有效推广的功能）
让Ploeh.SemanticComparison的Likeness在Name上做匹配
让 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();
    }
}

【讨论】：