时间戳

首页 > 解决方案 > 全局等效配置。排除成员

c# - 全局等效配置。排除成员

问题描述

我想知道是否可以为测试进行全局配置。我知道我可以像这样比较这个对象：

x.Should().BeEquivalentTo(y, opt => opt.Excluding(z => z.Member)

但我希望我的测试中的所有方法都使用这个配置。

标签： c#.netnunitfluent-assertions

解决方案

要从特定类型中排除成员，您可以创建自定义IMemberSelectionRule.

要对所有测试使用该选择规则，AssertionOptions.AssertEquivalencyUsing请在单元测试框架的某些设置方法中使用静态。请注意，AssertionOptions.AssertEquivalencyUsingFluent Assertions 的静态状态会发生变化，因此如果您正在并行运行测试，则应在运行任何测试之前调用它。对于不在命名空间[OneTimeSetUp]内的NUnit。[SetUpFixture]

using FluentAssertions;
using FluentAssertions.Equivalency;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;

[SetUpFixture]
public class MySetUpClass
{
    [OneTimeSetUp]
    public void RunBeforeAnyTests()
    {
        AssertionOptions.AssertEquivalencyUsing(e => e.Using(new MyNamespace.MyClassSelectionRule()));
    }
}

namespace MyNamespace
{
    class MyOuterClass
    {
        public MyInnerClass MemberToInclude { get; set; }

        public int MemberToExclude { get; set; }
    }

    class MyInnerClass
    {
        public int AnotherMemberToInclude { get; set; }

        public int MemberToExclude { get; set; }
    }

    internal class MyClassSelectionRule : IMemberSelectionRule
    {
        public bool IncludesMembers => false;

        public IEnumerable<SelectedMemberInfo> SelectMembers(IEnumerable<SelectedMemberInfo> selectedMembers, IMemberInfo context, IEquivalencyAssertionOptions config) =>
            selectedMembers.Where(e => !(e.DeclaringType.Name == nameof(MyOuterClass) && e.Name == nameof(MyOuterClass.MemberToExclude)));
    }

    [TestFixture]
    public class UnitTest1
    {
        [Test]
        public void Ignore_the_member_MemberToExclude_on_MyOuterClass()
        {
            var subject = new MyOuterClass
            {
                MemberToInclude = new MyInnerClass
                {
                    AnotherMemberToInclude = 42,
                    MemberToExclude = 42
                },
                MemberToExclude = 1
            };

            var expectation = new MyOuterClass
            {
                MemberToInclude = new MyInnerClass
                {
                    AnotherMemberToInclude = 42,
                    MemberToExclude = 42
                },
                MemberToExclude = 2
            };

            subject.Should().BeEquivalentTo(expectation);
        }

        [Test]
        public void Do_not_ignore_the_member_MemberToExclude_on_MyInnerClass()
        {
            var subject = new MyOuterClass
            {
                MemberToInclude = new MyInnerClass
                {
                    MemberToExclude = 1
                },
            };

            var expectation = new MyOuterClass
            {
                MemberToInclude = new MyInnerClass
                {
                    MemberToExclude = 2
                },
            };

            Action act = () => subject.Should().BeEquivalentTo(expectation);

            act.Should().Throw<AssertionException>();
        }
    }
}

推荐阅读