如何对返回 Func 的 C# 函数进行单元测试？

Question

我有一个类，其中包含一个返回 Result 对象的方法，该对象包含 Func 类型的属性。

class Result {
   public Func<Result> NextAction { get; set; }
}

如何编写有关此 Func 内容的单元测试断言？以下显然不起作用，因为编译器为 lambda 生成两种不同的方法：

// Arrange
ListController controller = new ListController(domain);
// Act
Result actual = controller.DefaultAction();
// Assert
Func<Result> expected = () => new ProductsController(domain).ListAction();
Assert.That(actual.NextAction, Is.EqualTo(expected));

我猜我可以通过使用表达式树来实现此目的，但是......有没有办法避免这样做？我正在使用 NUnit 2.5。

编辑： Result 对象中没有其他标识字段。它旨在成为一种基于当前对象/方法中做出的决策来调用下一个对象/方法的方法。

Answer 1

为什么不调用 Func 并比较返回值？

var actualValue = actual.NextAction();
var expectedValue = expected();
Assert.That(actualValue, Is.EqualTo(expectedValue));

编辑：我看到 Result 类没有任何标识。我猜想 Result 类中还有一些其他字段定义了 Result 的标识，可用于确定两个结果是否相等。

Answer 2

我不知道有一种简单的方法来查看 lambda 内部（除了如您所说的使用表达式树之外），但如果为委托分配了 方法组 代替。

var result1 = new Result {
    NextAction = new ProductsController(domain).ListAction };
var result2 = new Result {
    NextAction = new ProductsController(domain).ListAction };

//objects are different
Assert.That(result1, Is.Not.EqualTo(result2));

//delegates are different
Assert.That(result1.NextAction, Is.Not.EqualTo(result2.NextAction));

//methods are the same
Assert.That(result1.NextAction.Method, Is.EqualTo(result2.NextAction.Method));

如果您使用 lambda，上面的示例将不起作用，因为它们被编译为不同的方法。

Answer 3

如果您 Func 始终返回相同的结果，您可以测试函数返回哪个对象。

Answer 4

看来对 Func 的内容进行单元测试超出了单元测试的正常范围。 Func 表示已编译的代码，因此在不解析 MSIL 的情况下无法进一步检查。因此，在这种情况下，有必要依靠委托和实例化类型（如 Nathan Baulch 所建议的），或者改用表达式树。

我的表达式树等效如下：

class Result {
   public Expression<Func<Result>> NextAction { get; set; }
}

单元测试如下：

// Arrange
ListController controller = new ListController(domain);
// Act
Result actual = controller.DefaultAction();
// Assert
MethodCallExpression methodExpr = (MethodCallExpression)actual.NextAction.Body;
NewExpression newExpr = (NewExpression)methodExpr.Object;
Assert.That(newExpr.Type, Is.EqualTo(typeof(ProductsController)));
Assert.That(methodExpr.Method.Name, Is.EqualTo("ListAction"));

请注意，此测试存在一些固有的脆弱性，因为它暗示了表达式的结构及其行为。

Answer 5

如果我正确理解了这个问题，NextAction 可能有也可能没有不同的 lambda 实现，这就是需要测试的地方。

在下面的示例中，我比较了 IL 字节的方法。使用反射，从数组中的主体获取方法信息和 IL 字节。如果字节数组匹配，则 lambda 相同。

有很多情况这无法处理，但如果只是比较两个应该完全相同的 lambda 的问题，那么这将起作用。抱歉，它在 MSTest 中:)

using System.Reflection;
....


    [TestClass]
    public class Testing
    {
        [TestMethod]
        public void Results_lambdas_match( )
        {
            // Arrange 
            ListController testClass = new ListController( );
            Func<Result> expected = ( ) => new ProductsController( ).ListAction( );
            Result actual;
            byte[ ] actualMethodBytes;
            byte[ ] expectedMethodBytes;

            // Act 
            actual = testClass.DefaultAction( );

            // Assert
            actualMethodBytes = actual.NextAction.
                Method.GetMethodBody( ).GetILAsByteArray( );
            expectedMethodBytes = expected.
                Method.GetMethodBody( ).GetILAsByteArray( );

            // Test that the arrays are the same, more rigorous check really should
            // be done .. but this is an example :)
            for ( int count=0; count < actualMethodBytes.Length; count++ )
            {
                if ( actualMethodBytes[ count ] != expectedMethodBytes[ count ] )
                    throw new AssertFailedException(
                       "Method implementations are not the same" );
            }
        }
        [TestMethod]
        public void Results_lambdas_do_not_match( )
        {
            // Arrange 
            ListController testClass = new ListController( );
            Func<Result> expected = ( ) => new OtherController( ).ListAction( );
            Result actual;
            byte[ ] actualMethodBytes;
            byte[ ] expectedMethodBytes;
            int count=0;

            // Act 
            actual = testClass.DefaultAction( );

            // Assert
            actualMethodBytes = actual.NextAction.
                Method.GetMethodBody( ).GetILAsByteArray( );
            expectedMethodBytes = expected.
                Method.GetMethodBody( ).GetILAsByteArray( );

            // Test that the arrays aren't the same, more checking really should
            // be done .. but this is an example :)
            for ( ; count < actualMethodBytes.Length; count++ )
            {
                if ( actualMethodBytes[ count ] != expectedMethodBytes[ count ] )
                    break;
            }
            if ( ( count + 1 == actualMethodBytes.Length ) 
                && ( actualMethodBytes.Length == expectedMethodBytes.Length ) )
                throw new AssertFailedException(
                    "Method implementations are the same, they should NOT be." );
        }

        public class Result
        {
            public Func<Result> NextAction { get; set; }
        }
        public class ListController
        {
            public Result DefaultAction( )
            {
                Result result = new Result( );
                result.NextAction = ( ) => new ProductsController( ).ListAction( );

                return result;
            }
        }
        public class ProductsController
        {
            public Result ListAction( ) { return null; }
        }
        public class OtherController
        {
            public Result ListAction( ) { return null; }
        }
    }