Question

我对xUnit很陌生，这是我想要实现的目标：

[Theory]
[InlineData((Config y) => y.Param1)]
[InlineData((Config y) => y.Param2)]
public void HasConfiguration(Func<Config, string> item)
{
    var configuration = serviceProvider.GetService<GenericConfig>();
    var x = item(configuration.Config1); // Config1 is of type Config

    Assert.True(!string.IsNullOrEmpty(x));            
}

基本上，我有一个 GenericConfig 对象，其中包含 Config 和其他类型的配置，但我需要检查每个参数是否有效。由于它们都是字符串，我想简化使用 [InlineData] 属性而不是编写N等于测试。

不幸的是，我得到的错误是＆＃34;无法将lambda表达式转换为＆＃39; object []＆＃39;因为它不是代表类型＆＃34;，这非常清楚。

你对如何克服这个问题有任何想法吗？

Answer 1

除了已发布的答案。通过直接产生lambda可以简化测试用例。

public class ConfigTestDataProvider
{
    public static IEnumerable<object[]> TestCases
    {
        get
        {
            yield return new object [] { (Func<Config, object>)((x) => x.Param1) };
            yield return new object [] { (Func<Config, object>)((x) => x.Param2) };
        }
    }
}

此测试ConfigTestDataProvider可以直接注入lambdas。

[Theory]
[MemberData(nameof(ConfigTestCase.TestCases), MemberType = typeof(ConfigTestCase))]
public void Test(Func<Config, object> func)
{
    var config = serviceProvider.GetService<GenericConfig>();
    var result = func(config.Config1);

    Assert.True(!string.IsNullOrEmpty(result));
}

Answer 2

实际上，我找到的解决方案比Iqon提供的解决方案要好一些（谢谢！）。

显然，InlineData属性仅支持原始数据类型。如果您需要更复杂的类型，可以使用MemberData属性为单元测试提供来自自定义数据提供程序的数据。

以下是我解决问题的方法：

public class ConfigTestCase
{
    public static readonly IReadOnlyDictionary<string, Func<Config, string>> testCases = new Dictionary<string, Func<Config, string>>
    {
        { nameof(Config.Param1), (Config x) => x.Param1 },
        { nameof(Config.Param2), (Config x) => x.Param2 }
    }
    .ToImmutableDictionary();

    public static IEnumerable<object[]> TestCases
    {
        get
        {
            var items = new List<object[]>();

            foreach (var item in testCases)
                items.Add(new object[] { item.Key });

            return items;
        }
    }
}

这是测试方法：

[Theory]
[MemberData(nameof(ConfigTestCase.TestCases), MemberType = typeof(ConfigTestCase))]
public void Test(string currentField)
{
    var func = ConfigTestCase.testCases.FirstOrDefault(x => x.Key == currentField).Value;
    var config = serviceProvider.GetService<GenericConfig>();
    var result = func(config.Config1);

    Assert.True(!string.IsNullOrEmpty(result));
}

我可能会想出一些更好或更清洁的东西，但是现在它起作用并且代码不会重复。

Answer 3

奇怪的是，代表不是对象，但Func或object o = (Func<Config, string>)((Config y) => y.Param1)是。为此，您必须将lambda转换为其中一种类型。

Attribute

但是这样做，你的表情不再是常数了。因此，这会阻止在private void HasConfiguration(Func<Config, string> item) { var configuration = serviceProvider.GetService<GenericConfig>(); var x = item(configuration.Config1); // Config1 is of type Config Assert.True(!string.IsNullOrEmpty(x)); } [Theory] public Test1() { HasConfiguration((Config y) => y.Param1); } [Theory] public Test2() { HasConfiguration((Config y) => y.Param2); }中使用。

无法将lambdas作为属性传递。

一种可能的解决方案是使用函数调用而不是属性。不是很漂亮，但可以在没有重复代码的情况下解决您的问题：

<!-- ko foreach: { data: question, as: 'question' }-->
    <!-- ko foreach: { data: question.answers, as: 'answer' }-->
    <span data-bind="text: $parent[1].lang ? answer[$parent[1].lang + '_name'] : answer.name">
    <!-- /ko -->
<!-- /ko -->

Answer 4

我也遇到了同样的问题，并且找到了使用TheoryData类和MemberData属性的解决方案。这是示例，我希望代码有用：

public class FooServiceTest
{
    private IFooService _fooService;
    private Mock<IFooRepository> _fooRepository;

    //dummy data expression
    //first parameter is expression
    //second parameter is expected
    public static TheoryData<Expression<Func<Foo, bool>>, object> dataExpression = new TheoryData<Expression<Func<Foo, bool>>, object>()
    {
        { (p) => p.FooName == "Helios", "Helios" },
        { (p) => p.FooDescription == "Helios" && p.FooId == 1, "Helios" },
        { (p) => p.FooId == 2, "Poseidon" },
    };

    //dummy data source
    public static List<Foo> DataTest = new List<Foo>
    {
        new Foo() { FooId = 1, FooName = "Helios", FooDescription = "Helios Description" },
        new Foo() { FooId = 2, FooName = "Poseidon", FooDescription = "Poseidon Description" },
    };

    //constructor
    public FooServiceTest()
    {
        this._fooRepository = new Mock<IFooRepository>();
        this._fooService = new FooService(this._fooRepository.Object);
    }

    [Theory]
    [MemberData(nameof(dataExpression))]
    public void Find_Test(Expression<Func<Foo, bool>> expression, object expected)
    {
        this._fooRepository.Setup(setup => setup.FindAsync(It.IsAny<Expression<Func<Foo, bool>>>()))
                               .ReturnsAsync(DataTest.Where(expression.Compile()));

        var actual = this._fooService.FindAsync(expression).Result;
        Assert.Equal(expected, actual.FooName);
    }
}

Answer 5

public class HrcpDbTests
{    
    [Theory]
    [MemberData(nameof(TestData))]
    public void Test(Expression<Func<bool>> exp)
    {
        // Arrange
        // Act
        // Assert
    }
    
    public static IEnumerable<object[]> TestData 
    {
        get
        {
            Expression<Func<bool>> mockExp1 = () => 1 == 0;
            Expression<Func<bool>> mockExp2 = () => 1 != 2;

            return new List<object[]>
            {
                new object[]
                {
                    mockExp1
                },
                new object[]
                {
                    mockExp2
                }
            }
        }
    }
}

Lambda表达式作为xUnit中的内联数据

5 个答案: