使用DeepEquals忽略具有列表类型的属性

Question

我正在使用DeepEqual库来测试测试结果是否符合我的预期输出。

我做这个比较很简单

results.ShouldDeepEqual(expected);

但是，我不知道如何忽略列表类型中的属性

我深入比较的类型包含了一个列表。此列表中保存的数据类型包含我希望忽略的Guid属性Id以及日期。

忽略顶级属性可以很好地工作。但是，我不知道如何忽略列表类型上的属性。

为了解决这个问题，我必须自己编写一些代码来清除这些属性，但这显然并不理想。

for (var i = 0; i < results.MyList.Count; i++)
{
    results.MyList[i].Id = Guid.Empty;
    expectedResults.MyList[i].Id = Guid.Empty;
}

我怎样才能做到这一点？

Answer 1

通过查看DeepEqual的源代码，库允许通过IComparison接口进行自定义比较。在此基础上，我模拟了您所需的模型：

public class MyClass
{
    public MyClass()
    {
        MyList = new List<MySubClass>(new[]
        {
            new MySubClass {Id = Guid.Parse("1".PadLeft(32, '0')), Name = "Foo"}, 
            new MySubClass {Id = Guid.Parse("2".PadLeft(32, '0')), Name = "Bar"}, 
            new MySubClass {Id = Guid.Parse("3".PadLeft(32, '0')), Name = "Test"}, 
        });
    }

    public MyClass(params MySubClass[] subs)
    {
        MyList = new List<MySubClass>(subs);
    }
    
    public List<MySubClass> MyList { get; set; }
}

public class MySubClass
{
    public Guid Id { get; set; }
    public string Name { get; set; }
}

然后，我继续创建一个定制的IComparison类：

public class MySubClassComparer : IComparison
{
    public bool CanCompare(Type type1, Type type2)
    {
        return type1 == type2 && type1 == typeof(MySubClass);
    }

    public (ComparisonResult result, IComparisonContext context) Compare(IComparisonContext context, object value1, object value2)
    {
        if (value1 is MySubClass first && value2 is MySubClass second)
        {
            if (first.Name == second.Name)
            {
                return (ComparisonResult.Pass, context);
            }
        }

        return (ComparisonResult.Fail, context);
    }
}

下面是我通过的两个单元测试：

[Fact]
public void IsDeepEqual_ShouldReturnTrue_WhenListHasSameNames()
{
    // Arrange
    MyClass sut = new MyClass();
    MyClass parameter = new MyClass(new[]
    {
        new MySubClass {Id = Guid.Parse("4".PadLeft(32, '0')), Name = "Foo"},
        new MySubClass {Id = Guid.Parse("5".PadLeft(32, '0')), Name = "Bar"},
        new MySubClass {Id = Guid.Parse("6".PadLeft(32, '0')), Name = "Test"},
    });
    var comparer = new ComparisonBuilder().WithCustomComparison(new MySubClassComparer()).Create();

    // Act
    bool result = sut.IsDeepEqual(parameter, comparer);

    // Assert
    Assert.True(result);
}

[Fact]
public void IsDeepEqual_ShouldReturnFalse_WhenListHasDifferentNames()
{
    // Arrange
    MyClass sut = new MyClass();
    MyClass parameter = new MyClass(new[]
    {
        new MySubClass {Id = Guid.Parse("4".PadLeft(32, '0')), Name = "Foo"},
        new MySubClass {Id = Guid.Parse("5".PadLeft(32, '0')), Name = "Bar"},
        new MySubClass {Id = Guid.Parse("6".PadLeft(32, '0')), Name = "Fail"},
    });
    var comparer = new ComparisonBuilder().WithCustomComparison(new MySubClassComparer()).Create();

    // Act
    bool result = sut.IsDeepEqual(parameter, comparer);

    // Assert
    Assert.False(result);
}

Notes这个比较应该忽略Id属性，但我不确定这是否是完成任务的最佳方式。有一个IgnoreProperty方法可能更适合该任务，但无法找到使其当前工作的方法。

如果有人有更多的经验，那么我做图书馆，请让我知道更好的方法，我会更新我的答案相应。

Answer 2

现在，DeepEqual库使它变得相当简单。写下来就足够了：

results.WithDeepEqual(expected).IgnoreProperty<MySubClass>(x => x.Id).Assert();

如果我们进行海登单元测试并稍微补充它们，您将得到如下内容：

using System;
using Xunit;
using DeepEqual.Syntax;
using System.Collections.Generic;

public class MyClass
{
    public List<MySubClass> MyList { get; } = new List<MySubClass>
    {
        new MySubClass {Id = Guid.NewGuid(), Name = "Foo"},
        new MySubClass {Id = Guid.NewGuid(), Name = "Bar"},
        new MySubClass {Id = Guid.NewGuid(), Name = "Test"}
    };
}

public class MySubClass
{
    public Guid Id { get; init; }

    public string Name { get; init; }
}

public class DeepEqualTests
{
    [Fact]
    public void FullDeepEqualTest()
    {
        // Arrange
        var first = new MyClass();
        var second = new MyClass();

        // Act
        Action compassion = () => first
            .ShouldDeepEqual(second);

        // Assert
        Assert.Throws<DeepEqualException>(compassion);
    }

    [Fact]
    public void DeepEqualWithoutIdTest()
    {
        // Arrange
        var first = new MyClass();
        var second = new MyClass();

        // Act
        Action compassion = () => first
            .WithDeepEqual(second)
            .IgnoreProperty<MySubClass>(x => x.Id)
            .Assert();

        // Assert
        compassion();
    }
}

第一个测试是一个完整的比较，并期望出现异常。第二个测试将在比较时忽略ID字段，如果没有抛出异常，则成功。这两个测试都成功运行。