标签: fluent-assertions

我正在使用specflow编写一些单元测试,需要一种方法来检查对象列表是否按特定属性排序.目前我这样做,但我不确定这是否是最佳方式.

var listFromApi = listOfObjects;

var sortedList = listFromApi.OrderBy(x => x.Property);

Assert.IsTrue(listFromApi.SequenceEqual(sortedList));

有没有一种很好的方法可以使用Fluent Assertions完成？

我从文档中知道我可以做到这一点......

result.Should().BeOfType<MyClass>().Which.Property1.Should().Be("String")

有没有一种方法可以以类似的方式测试多个属性

result.Should().BeOfType<MyClass>().Which.Property1.Should().Be("String").And.Property2.Should().Be(99);

如果可以执行上述任一测试而不必断言它们是“OfType”，那也很好，但我怀疑代码没有其他方法可以知道哪些属性可用。

我有一个列表，每个元素也应该显示在另一个列表中，但不一定以相同的顺序显示。

我可能可以像这样用 foreach 来做断言

Assert.IsTrue(list1.Count == list2.Count);
foreach(var element in list1)
{
    Assert.IsTrue(list2.Count(e => e.Equals(element)) == 1);
}

我正在寻找一种使用 fluentAssertions 做到这一点的方法。元素不一定是相等的，而是等价的。它可能是这样的

list1.ShouldAll().BeEquivalentInAnyOrderTo(list2);

但是我找不到任何可以轻松解决我的问题的东西。

使用 FluentAssertions 检查两个列表是否以任何顺序包含等效元素的最简单方法是什么？

我有RuleInfo从内部类创建的公共类Rule。

private static RuleInfo CreateRuleInfo(Rule r)
{
    return new RuleInfo
    {
        RuleCode = r.RuleId,
        DisplayName = r.RuleCode,
        Description = r.Description,
        LegacyRuleCode = null
    };
}

它们的属性名称各不相同，因此ShouldBeEquivalentTo()或ShouldAllBeEquivalentTo()不起作用。

现在我正在手动/明确地比较它们：

foreach (var x in Enumerable.Zip(infs, rules, (i, r) => new { Info = i, Rule = r }))
{
    x.Info.ShouldBeEquivalentTo(
        new
        {
            RuleCode = x.Rule.RuleId,
            DisplayName = x.Rule.RuleCode,
            Description = x.Rule.Description,
            LegacyRuleCode = (string)null
        });
}

有没有更好、更紧凑、更简洁、更易读的方式？

如何使用 FluentAssertions 轻松比较字符串不区分大小写？

就像是：

symbol.Should().Be(expectedSymbol, StringComparison.InvariantCultureIgnoreCase);

编辑：关于可能的重复和代码： symbol.Should().BeEquivalentTo(expectedSymbol);

它正在比较使用 CurrentCulture。它会在像土耳其文化这样的情况下刹车。在哪里 Thread.CurrentThread.CurrentCulture = new CultureInfo("tr-TR", false); string upper = "in".ToUpper(); // upper == "?N" "in".Should().BeEquivalentTo("In"); // It will fail

所以“ StringComparison.InvariantCultureIgnoreCase ”部分在这里至关重要。

我不确定旧版本的 FluentAssertions 是否有这个，但我想将一个集合与另一个集合进行比较。我有一个像这样的dto：

public class UserDTO
{
    public int Id { get; set; }
    public string Username { get; set; }
}

我有两个我想比较的列表。

 List<UserDTO> createdUsers = this.GetCreatedUser();
 var expectedResults = this.dbContext.Users.Top(10);

我看到的最接近的应该都是等价的：

 createdUsers.Should().AllBeEquivalentTo(expectedResults)

但是当我尝试通过排除项时，它似乎在为我提供列表的排除项，而不是实体本身。

我想比较其中的两个列表，不包括 Id 属性。我可以发誓有一个名为的函数ShouldAllBeEquivalentTo，它接受允许排除的选项，

createdUsers.ShouldAllBeEquivalentTo(expectedResults, o => o.Excluding(x => x.Id);

如何在比较集合的同时排除比较中的属性？

我在用着FluentAssertions。

对于同步测试，我可以这样写：

action.Should().Throw<ArgumentNullException>().And.ParamName.Should().Be("foo");

对于异步测试，我这样做：

await action.Should().ThrowAsync<ArgumentNullException>();

是否有一种方便的方法来断言ParamName，或者我必须通过包装在 try-catch 中手动完成？

我有以下DTO:

public class Dto
{
    public DateTime Date { get; set; }
}

我试图根据FA维基使用这种语法覆盖属性的比较:

public void Override_test()
{
    // Arrange
    var actual = new Dto { Date = DateTime.Now };
    var expected = new Dto { Date = DateTime.Now };

    // Act

    // Assert
    actual.ShouldBeEquivalentTo(expected, options => 
        options.Using<DateTime>(x => x.Subject.Should().BeCloseTo(DateTime.Now)));
}

但是测试没有编译.我收到此错误:

Cannot implicitly convert type 'FluentAssertions.Equivalency.EquivalencyAssertionOptions<FluentAssertions.ShouldBeEquivalentTo.Override.Dto>.Restriction<System.DateTime>' to 'FluentAssertions.Equivalency.EquivalencyAssertionOptions<FluentAssertions.ShouldBeEquivalentTo.Override.Dto>'

任何人都可以建议正确的语法吗？

我有两个具有不同项类型的集合,例如:

var collection1 = new List<Type1>();
var collection2 = new List<Type2>();

是否可以使用我自己的相等比较器和FluentAssertions 断言具有不同项类型的两个集合包含任何顺序的相同项？

官方FA文档中最相关的示例认为两个集合都是相同的类型:

persistedCustomers.Should().Equal(customers, (c1, c2) => c1.Name == c2.Name);

在我的情况下使用这种方法的一种可能的解决方案是List<Type1>基于来自的项创建新集合collection2并使用它而不是customers在上面的示例中.
但有时它只是不可能,实际上闻起来像是一种开销.

我想知道是否有类似的方法使用像上面的FA优雅,但适合不同项目类型的集合？

更新1(尝试使用@DennisDoomen建议):

让我们来看一个更具体的例子.
假设我们有一个List<DateTime>表示单个月日期的预期值:

    var expectation = new List<DateTime>();

测试方法返回List<int>一天数:

    var actual = new List<int>();

我们想断言测试方法返回的日期数集与期望列表的DateTime.Day值组成的集合相同,即:

    Assert.AreEqual(expectation[0].Day, actual[0]);
    Assert.AreEqual(expectation[1].Day, actual[1]);
...
    Assert.AreEqual(expectation[expectation.Count - 1].Day, actual[actual.Count - 1]);

(但没有排序限制,我不知道如何在这个例子中演示).

我试图以这种方式使用@DennisDoomen建议:

    actual.ShouldBeEquivalentTo(
        expectation,
        options => options.Using<int>(
            ctx => ctx.Subject.Should().Be(ctx.Expectation.Day)).WhenTypeIs<int>());

问题是,ctx.Expectation这是一种类型int,而不是一种 …

使用FluentAssertions:
我可以使用ShouldBeEquivalentTo 排除单个属性.

x.ShouldBeEquivalentTo(y, opts => opts.Excluding(si => !si.PropertyInfo.CanWrite));

但是,在使用ShouldBeEquivalentTo()时如何排除多于1个属性？