如何高效测试含多属性类的IEquatable实现正确性？

问题背景 #

我有一个实现了IEquatable<ComponentDefinitionRoot>接口的类，定义如下：

class ComponentDefinitionRoot: IEquatable<ComponentDefinitionRoot>
{
    public string Id {get; set;}
    public string Name {get; set;}

    // 更多属性...

    public virtual bool Equals(ComponentDefinitionRoot? other)
    {
        if (other is null)
            return false;
       
        return Name == other.Name && Id == other.Id // 以及其他属性的比较;
    }
}

这个类包含多个属性，部分复杂数据结构也实现了自定义Equals方法。我已经完成了IEquatable的实现且功能正常，现在需要对Equals的正确性做单元测试。

目前我写的测试代码如下，通过构造仅单个属性不同的对象来覆盖所有场景，但这种方式非常繁琐：

[TestMethod]
[DynamicData(nameof(GetTestCases), DynamicDataSourceType.Method)]
public void Equals_AreNotEqual_ReturnsFalse(ComponentDefinitionRoot unequalRoot)
{
    var root1 = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();

    bool areEqual = root1.Equals(unequalRoot);

    Assert.IsFalse(areEqual);
}

[TestMethod]
public void Equals_AreEqual_ReturnsTrue()
{
    var root1 = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    var equalToRoot1 = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();

    bool areEqual = root1.Equals(equalToRoot1);

    Assert.IsTrue(areEqual);
}

public static IEnumerable<object[]> GetTestCases()
{
    yield return new object[] { NameDifferent() };
    yield return new object[] { IdDifferent() };
    yield return new object[] { CreatedDateDifferent() };
    yield return new object[] { SegmentNameDifferent() };
    // 更多测试用例...
}

public static ComponentDefinitionRoot NameDifferent()
{
    var result = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    result.Name = "not equal";
    return result;
}

public static ComponentDefinitionRoot IdDifferent()
{
    var result = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    result.Id = "000000000000000000000002";
    return result;
}

public static ComponentDefinitionRoot CreatedDateDifferent()
{
    var result = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    result.CreatedDate = GeneralMother.GetIndependenceDay();
    return result;
}

public static ComponentDefinitionRoot SegmentNameDifferent()
{
    var result = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    result.Segments.First().Name = "unequal name";
    return result;
}

请问有没有更优的方案来简化这种测试？

优化思路 #

1. 用委托批量生成测试用例 #

把每个属性的修改逻辑封装成Action委托，通过通用方法完成对象拷贝和修改，避免重复编写单独的属性修改方法：

public static IEnumerable<object[]> GetTestCases()
{
    var baseObj = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    
    yield return new object[] { Modify(baseObj, x => x.Name = "not equal") };
    yield return new object[] { Modify(baseObj, x => x.Id = "000000000000000000000002") };
    yield return new object[] { Modify(baseObj, x => x.CreatedDate = GeneralMother.GetIndependenceDay()) };
    yield return new object[] { Modify(baseObj, x => x.Segments.First().Name = "unequal name") };
    // 新增测试用例只需添加一行
}

// 通用修改方法，确保深拷贝原对象避免测试污染
private static ComponentDefinitionRoot Modify(ComponentDefinitionRoot original, Action<ComponentDefinitionRoot> modifyAction)
{
    var copy = DeepCopy(original);
    modifyAction(copy);
    return copy;
}

// 实现深拷贝，可根据实际场景选择序列化、AutoMapper或手动拷贝
private static ComponentDefinitionRoot DeepCopy(ComponentDefinitionRoot obj)
{
    var json = JsonSerializer.Serialize(obj);
    return JsonSerializer.Deserialize<ComponentDefinitionRoot>(json);
}

2. 改用更简洁的参数化测试框架 #

如果切换到xUnit，利用Theory和MemberData特性可以更直观地管理测试用例，还能给每个用例添加描述：

public static IEnumerable<object[]> UnequalCases()
{
    var baseObj = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    
    yield return new object[] { "名称不同", Modify(baseObj, x => x.Name = "not equal") };
    yield return new object[] { ID不同", Modify(baseObj, x => x.Id = "000000000000000000000002") };
    // 更多用例
}

[Theory]
[MemberData(nameof(UnequalCases))]
public void Equals_WhenSinglePropertyDiffers_ReturnsFalse(string caseDesc, ComponentDefinitionRoot unequalObj)
{
    var original = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    Assert.False(original.Equals(unequalObj), caseDesc);
}

3. 反射自动生成测试用例（进阶） #

如果类的属性数量极多，可以通过反射遍历所有可写属性，自动生成“单个属性修改”的测试用例，适合属性多且结构相对简单的场景：

public static IEnumerable<object[]> AutoGeneratedUnequalCases()
{
    var baseObj = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    var type = typeof(ComponentDefinitionRoot);
    
    // 遍历所有可写公共属性
    foreach (var prop in type.GetProperties(BindingFlags.Public | BindingFlags.Instance).Where(p => p.CanWrite))
    {
        var copy = DeepCopy(baseObj);
        object newValue = GetDifferentValue(prop.PropertyType, prop.GetValue(baseObj));
        prop.SetValue(copy, newValue);
        yield return new object[] { $"修改{prop.Name}", copy };
    }
    
    // 处理嵌套集合属性，比如Segments
    if (baseObj.Segments?.Any() == true)
    {
        var copy = DeepCopy(baseObj);
        copy.Segments.First().Name = $"修改SegmentName_{Guid.NewGuid()}";
        yield return new object[] { "修改第一个Segment名称", copy };
    }
}

// 根据属性类型生成差异化测试值
private static object GetDifferentValue(Type propType, object originalValue)
{
    if (propType == typeof(string))
        return $"{originalValue}_modified";
    if (propType == typeof(Guid))
        return Guid.NewGuid();
    if (propType == typeof(DateTime))
        return DateTime.Now.AddDays(1);
    if (propType.IsValueType)
        return Activator.CreateInstance(propType);
    return Activator.CreateInstance(propType);
}

4. 用比较库辅助验证 #

使用FluentAssertions这类库，可以同时验证Equals逻辑和属性一致性，还能输出详细差异：

[TestMethod]
public void Equals_ShouldMatchPropertyComparison()
{
    var original = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    var equalObj = ComponentDefinitionEntityMother.MakeComponentDefinitionRootA();
    var unequalObj = Modify(original, x => x.Name = "different");
    
    // 验证相等场景
    original.Equals(equalObj).Should().BeTrue();
    original.Should().BeEquivalentTo(equalObj);
    
    // 验证不等场景
    original.Equals(unequalObj).Should().BeFalse();
    original.Should().NotBeEquivalentTo(unequalObj);
}

内容的提问来源于stack exchange，提问作者David Mason