FluentAssertions：检查一个列表是否包含一个对象，不包括一个属性答案

【问题标题】：FluentAssertions: check a list contains an object, excluding a propertyFluentAssertions：检查一个列表是否包含一个对象，不包括一个属性
【发布时间】：2017-08-21 13:00:08
【问题描述】：

我有几个实现 IEvent 的事件类。为了检查实际事件与我使用的预期事件

actualEvent.ShouldBeEquivalentTo(expectedEvent,opt => opt.RespectingRuntimeTypes()
                                                         .Excluding(e => e.DateCreated));

这些事件有一个 DateCreated 属性，我忽略了它，因为实际和预期是在不同时间创建的。

如何检查 expectedEvent 在actualEvents 列表中是否至少存在一次？

我想做以下事情；

actualEvents.Should().Contain(expectedEvent,opt => opt.RespectingRuntimeTypes()
                                                      .Excluding(e => e.DateCreated));

但这是不可能的。

这可以在fluentassertions中完成吗？

【问题讨论】：

标签： .net fluent-assertions

【解决方案1】：

我有一个类似的场景，我有一个项目列表（一个具有属性的对象），我想检查该列表是否包含我正在测试的本地项目。

我找到了这个问题的解决方案：FluentAssertions, making sure IEnumerable contains only single element

我通过编写以下语句简化了我的解决方案：

FooList.Should().Contain(fooItem, x => true)

上述约束表明 FooList 对象应包含 fooItem，这用 lambda x => true 表示。

相当直截了当，适用于我的用例。试一试，看看我链接的那个问题线程可能会有所帮助。

祝你好运。

【讨论】：

【解决方案2】：

使用 FluentAssertions 4.19.4，我通过实现自己的扩展方法解决了这个问题。

集合中的每个元素都针对预期元素单独声明，使用可以接受配置参数的 ShouldBeEquivalentTo 方法。

using FluentAssertions.Collections;
using FluentAssertions.Equivalency;
using FluentAssertions.Execution;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;

namespace FluentAssertions.Extensions
{
    public static class FluentAssertionsHelper
    {
        public static AndWhichConstraint<TAssertions, T> Contain<TAssertions, T>(this SelfReferencingCollectionAssertions<T, TAssertions> colAssert,
            T expected,
            Func<EquivalencyAssertionOptions<T>, EquivalencyAssertionOptions<T>> config,
            string because = "",
            params object[] becauseArgs) where TAssertions : SelfReferencingCollectionAssertions<T, TAssertions>
        {
            var items = colAssert.Subject;

            if (items == null)
            {
                Execute.Assertion.BecauseOf(because, becauseArgs).FailWith("Expected {context:collection} to contain {0}{reason}, but found {1}.", expected, items);
            }

            var containsItem = false;

            using (var scope = new AssertionScope())
            {
                foreach (var item in items)
                {
                    try
                    {
                        item.ShouldBeEquivalentTo(expected, config, because, becauseArgs);
                    }
                    catch (NullReferenceException) { }

                    var failures = scope.Discard();
                    if (!failures.Any())
                    {
                        containsItem = true;
                        break;
                    }
                }
            }

            if (!containsItem)
            {
                Execute.Assertion.BecauseOf(because, becauseArgs).FailWith("Expected {context:collection} {0} to contain {1}{reason}.", items, expected);
            }

            return new AndWhichConstraint<TAssertions, T>((TAssertions)colAssert, items.Where(item => EqualityComparer<T>.Default.Equals(item, expected)));
        }
    }
}

然后您可以编写以下内容：

using FluentAssertions;
using FluentAssertions.Extensions;

collection.Should().Contain(item, config => config.Excluding(item => item.MyProperty));

【讨论】：