NUnit 有条件拆卸？

Question

有没有办法在 NUnit 中进行有条件的 TearDown？

我有一个 TestFixture，它只需要为几个测试运行清理代码，但我真的不想：

1. 在每个测试上运行 TearDown 方法
2. 创建一个私有帮助器方法，如果可以的话，从需要清理的测试中调用它躲开它

Answer 1

不幸的是没有。

当所有测试完成后，您是否可以不在 [TestFixtureTearDown] 中进行清理？ 我想这取决于是否必须在下一次测试运行之前完成清理。

或者，将需要清理的测试放在另一个类/TextFixture 中，远离其他测试。 然后您可以在其中使用不需要条件的 TearDown。

编辑：
我刚刚想到的一件事是，您可以扩展 NUnit - 创建您自己的自定义属性，您可以根据需要处理这些属性，尽管对于这种特殊需求来说可能实际上并不值得。 此处提到了这一点 。 就像我说的，我认为你不应该为此走这条路，但了解这一点还是很有用的

Answer 2

您可以将主 TearDown 放在基类中：

[TearDown]
public virtual void TearDown()
{
  // Tear down things here
}

然后在具有不应运行拆卸代码的测试的类中覆盖它：

[TearDown]
public override void TearDown()
{
  // By not calling base.TearDown() here you avoid tearing down
}

Answer 3

使用BaseTest 中的测试扩展所有类，

    public class BaseTest
    {
        [SetUp]
        public void BeforeTest()
        {
            GetService<NUnitHooksController>().ExecuteBeforeTestHooks(this);
        }

        [TearDown]
        public void AfterTest()
        {
            GetService<NUnitHooksController>().ExecuteAfterTestHooks(this);
        }
    }

使用 AfterTest 和 BeforeTest 挂钩。 无论有类别还是无类别都适用。

    public class ExampleTest : BaseTest
    {
        [Test, Category("asdasd")]
        public void Test01()
        {
           ...
        }

        [AfterTest("asdasd")]
        public void ExampleHook()
        {
           ...
        }

    }

    public class NUnitHooksController
    {
        private readonly ILogger _log;

        public NUnitHooksController(ILogger log)
        {
            _log = log;
        }

        public void ExecuteBeforeTestHooks(object testClass)
        {
            ExecuteHooks(testClass, typeof(BeforeTestAttribute));
        }

        public void ExecuteAfterTestHooks(object testClass)
        {
            ExecuteHooks(testClass, typeof(AfterTestAttribute));
        }

        private MethodInfo[] GetHookMethods(object currentTestClass, Type attributeType)
        {
            return currentTestClass
                .GetType()
                .GetMethods()
                .Where(m => m.GetCustomAttributes(attributeType, false).Length > 0)
                .ToArray();
        }

        private void ExecuteHooks(object testClass, Type requiredAttributeType)
        {
            var hooks = GetHookMethods(testClass, requiredAttributeType);
            var testCategories = GetTestCategories();

            foreach (var hook in hooks)
            {
                var allAttributes = hook.GetCustomAttributes(requiredAttributeType, true);
                foreach (var attribute in allAttributes)
                {
                    if (!attribute.GetType().IsEquivalentTo(requiredAttributeType))
                    {
                        continue;
                    }

                    var hookCategories = GetCategoriesFromAttribute(attribute);

                    // if we do not have specific category on hook
                    // or we have at least one same category on hook and test
                    if (!hookCategories.Any() || hookCategories.Intersect(testCategories).Any())
                    {
                        ExecuteHookMethod(testClass, hook);
                    }
                }
            }
        }

        private object[] GetTestCategories()
        {
            return TestContext.CurrentContext.Test.Properties["Category"].ToArray();
        }

        private void ExecuteHookMethod(object testClass, MethodInfo method)
        {
            var hookName = method.Name;
            _log.Information($"Executing - '{hookName}' hook");

            try
            {
                method.Invoke(testClass, Array.Empty<object>());
            }
            catch (Exception e)
            {
                _log.Error($"Executing of - '{hookName}' hook failed - {e}");
            }
        }

        private string[] GetCategoriesFromAttribute(object attribute)
        {
            if (attribute is BeforeTestAttribute beforeTestAttribute)
            {
                return beforeTestAttribute.Categories;
            }

            if (attribute is AfterTestAttribute afterTestAttribute)
            {
                return afterTestAttribute.Categories;
            }

            throw new ArgumentException($"{attribute.GetType().FullName} - does not have categories");
        }
    }

Answer 4

我已经使用测试名称解决了这个问题：

namespace TestProject
{
    public class TestClass
    {
        // Test without TearDown
        [Test]
        public void Test1()
        {
            Assert.Pass("Test1 passed");
        }

        // Test with TearDown
        [Test]
        public void Test2()
        {
            Assert.Pass("Test2 passed");
        }

        [TearDown]
        public void TearDown()
        {
            // Execute only after Test2
            if (TestContext.CurrentContext.Test.Name.Equals(nameof(this.Test2)))
            {
                // Execute Test2 TearDown...
            }
        }
    }
}

或者，如果您想使用 Test2 (TestProject.TestClass.Test2) 的全名，您可以将该行替换

if (TestContext.CurrentContext.Test.Name.Equals(nameof(this.Test2)))

为

if (TestContext.CurrentContext.Test.FullName.Equals(typeof(TestClass).FullName + "." nameof(this.Test2)))