FluentAssertions Should().BeEquivalentTo 不比较 EF 动态代理上的运行时派生类型

Question

我正在使用 FluentAssertions 使用 Should().BeEquivalentTo() 比较两个对象，其中一个对象是 EF 动态代理。但是，5.0.0 中ShouldBeEquivalentTo 和ShouldAllBeEquivalentTo (#593) 的统一似乎破坏了使用RespectingRuntimeTypes 时的功能。除非我为对象图中的每个类型显式添加ComparingByMembers，否则不再比较已声明类型的派生类型的属性成员。有没有办法使用其他设置解决这个问题？

Answer 1

我已经编写了以下扩展方法来尝试解决该问题，但仅在运行时在动态代理上解决派生类型的问题似乎很麻烦：

public static class FluentAssertionsExtensions
{
    /// <summary>
    /// Extends the functionality of <see cref="EquivalencyAssertionOptions{TExpectation}" />.ComparingByMembers by recursing into the entire object graph
    /// of the T or passed object and marks all property reference types as types that should be compared by its members even though it may override the
    /// System.Object.Equals(System.Object) method. T should be used in conjunction with RespectingDeclaredTypes. The passed object should be used in
    /// conjunction with RespectingRuntimeTypes.
    /// </summary>
    public static EquivalencyAssertionOptions<T> ComparingByMembersRecursive<T>(this EquivalencyAssertionOptions<T> options, object obj = null)
    {
        var handledTypes = new HashSet<Type>();
        var items = new Stack<(object obj, Type type)>(new[] { (obj, obj?.GetType() ?? typeof(T)) });

        while (items.Any())
        {
            (object obj, Type type) item = items.Pop();
            Type type = item.obj?.GetType() ?? item.type;

            if (!handledTypes.Contains(type))
            {
                handledTypes.Add(type);

                foreach (PropertyInfo pi in type.GetProperties())
                {
                    object nextObject = item.obj != null ? pi.GetValue(item.obj) : null;
                    Type nextType = nextObject?.GetType() ?? pi.PropertyType;

                    // Skip string as it is essentially an array of chars, and needn't be processed.
                    if (nextType != typeof(string))
                    {
                        if (nextType.GetInterface(nameof(IEnumerable)) != null)
                        {
                            nextType = nextType.HasElementType ? nextType.GetElementType() : nextType.GetGenericArguments().First();

                            if (nextObject != null)
                            {
                                // Look at all objects in a collection in case any derive from the collection element type.
                                foreach (object enumObj in (IEnumerable)nextObject)
                                {
                                    items.Push((enumObj, nextType));
                                }

                                continue;
                            }
                        }

                        items.Push((nextObject, nextType));
                    }
                }

                if (type.IsClass && type != typeof(string))
                {
                    // ReSharper disable once PossibleNullReferenceException
                    options = (EquivalencyAssertionOptions<T>)options
                        .GetType()
                        .GetMethod(nameof(EquivalencyAssertionOptions<T>.ComparingByMembers))
                        .MakeGenericMethod(type).Invoke(options, null);
                }
            }
        }

        return options;
    }
}

应该这样调用：

foo.Should().BeEquivalentTo(bar, o => o
    .RespectingRuntimeTypes()
    .ComparingByMembersRecursive(foo)
    .ExcludingMissingMembers());

Answer 2

我最近使用Microsoft.EntityFrameworkCore.Proxies 遇到了同样的问题。就我而言，我必须比较持久属性，而忽略比较其余的甚至导航属性。

解决方案是实现接口FluentAssertions.Equivalency.IMemberSelectionRule 以排除不必要的属性。

public class PersistentPropertiesSelectionRule<TEntity> : IMemberSelectionRule 
    where TEntity : class
{
    public PersistentPropertiesSelectionRule(DbContext dbContext) => 
        this.dbContext = dbContext;

    public bool IncludesMembers => false;

    public IEnumerable<SelectedMemberInfo> SelectMembers(
        IEnumerable<SelectedMemberInfo> selectedMembers, 
        IMemberInfo context, 
        IEquivalencyAssertionOptions config)
    {
        var dbPropertyNames = dbContext.Model
            .FindEntityType(typeof(TEntity))
            .GetProperties()
            .Select(p => p.Name)
            .ToArray();

        return selectedMembers.Where(x => dbPropertyNames.Contains(x.Name));
    }

    public override string ToString() => "Include only persistent properties";

    readonly DbContext dbContext;
}

然后编写一个扩展方法可以帮助方便使用并提高可读性。扩展方法可以是下面这段代码。

public static class FluentAssertionExtensions
{
    public static EquivalencyAssertionOptions<TEntity> IncludingPersistentProperties<TEntity>(this EquivalencyAssertionOptions<TEntity> options, DbContext dbContext) 
        where TEntity : class
    {
        return options.Using(new PersistentPropertiesSelectionRule<TEntity>(dbContext));
    }
}

最后，您可以像下面的代码一样调用测试中的扩展方法。

// Assert something
using (var context = DbContextFactory.Create())
{
    var myEntitySet = context.MyEntities.ToArray();
    myEntitySet.Should().BeEquivalentTo(expectedEntities, options => options
        .IncludingPersistentProperties(context)
        .Excluding(r => r.MyPrimaryKey));
}

这个实现解决了我的问题，代码看起来很整洁。