标签: fluent-assertions

我对这段代码感到有些困惑(这是一个例子):

public async Task Fail()
{
    await Task.Run(() => { throw new Exception(); });
}

[Test]
public async Task TestFail()
{
    Action a = async () => { await Fail(); };
    a.ShouldThrow<Exception>();
}

代码没有捕获异常,并且失败了

期望抛出System.Exception,但没有抛出异常.

我确定我错过了一些东西,但是文档似乎暗示这是要走的路.一些帮助将不胜感激.

我正在尝试使用C#中的Fluent Assertions为超过重写的运算符编写单元测试.如果其中一个对象为null,则此类中的大于运算符应该抛出异常.

通常在使用Fluent Assertions时,我会使用lambda表达式将该方法放入一个动作中.然后我会运行动作并使用action.ShouldThrow<Exception>.但是,我无法弄清楚如何将运算符放入lambda表达式.

我宁愿不使用NUnit Assert.Throws(),ThrowsConstraint或[ExpectedException]属性来保持一致性.

我有两节课:

public class ClassA
{
  public int? ID {get; set;}
  public IEnumerable<ClassB> Children {get; set;}
}

public class ClassB
{
  public int? ID {get; set;}
  public string Name {get; set;}
}

我想使用流畅的断言来与ClassA实例进行比较.但是我想忽略ID(因为ID将在保存后分配).

我知道我可以这样做:

expectedA.ShouldBeEquivalentTo(actualA, options => options.Excluding(x => x.PropertyPath == "Children[0].ID"));

对于集合中的每个ClassB,我显然可以重复这一点.但是我正在寻找一种方法来排除所有ID(而不是对每个元素进行排除).

我已经读过这个问题但是如果我删除了[0]索引器,断言就会失败.

这可能吗？

任何人都可以总结它们之间的差异和使用范围吗？

我读了SO文章,

• ShouldBeEquivalientTo():ShouldBeEquivalentTo()旨在用于比较复杂的对象图,而不是.NET框架的基本类型部分.
• 应该().BeEquivalentTo():单个项目Equals()实现以验证等效性并且自版本1以来一直存在.在FA 2.0中引入的较新的ShouldBeEquivalenTo()正在进行深入的结构比较并报告任何差异.
• 应该().Be():找不到.

在我的谦虚理解ShouldBeEquivalientTo()和Should().BeEquivalentTo()工作相似的情况下,如果Should().BeEquivalentTo()进行深入的比较.

我正在尝试使用C#中的FluentAssertions建立两个列表的等价,其中有两件事是重要的:

1. 元素通过它们持有的值进行比较,而不是通过引用进行比较(即它们是等价的,不相等)
2. 列表中元素的顺序很重要

FluentAssertions(甚至是NUnit)中没有这样做的功能吗？

干杯!

通常,如果在某种方法中抛出异常,则进行测试,如下所示.我使用FluentAssertions:

[Fact]
public void Exception_gets_thrown()
{
    // Arrange
    var foo = new Foo("validArgument");

    // Act/Assert
    foo.Invoking(f => f.Bar(null))            // null is an invalid argument
       .ShouldThrow<ArgumentNullException>();
}

但是如果在构造函数中抛出异常,如何测试呢？我只是这样做了,但是通过FluentAssertions可能有更合适的方法吗？

[Fact]
public void Constructor_throws_Exception()
{
    // Arrange
    Action a = () => new Foo(null);         // null is an invalid argument

    // Act/Assert
    a.ShouldThrow<ArgumentNullException>();
}

假设我想测试一个方法,使用fluent-assertions返回一堆以下类型的项,以确保所有项的IsActive-flag都设置为true:

public class Item
{
    public bool IsActive { get; set; }
}

为了实现这一点,我可以简单地迭代集合并在foreach循环中单独断言每个项目:

var items = CreateABunchOfActiveItems();
foreach (var item in items)
{
    item.IsActive.Should().BeTrue("because I said so!");
}

但是,是否有更流畅的方式同时断言整个系列中的每个项目？

在Fluent Assertions中,将对象与DateTime属性进行比较时,有时会在毫秒内出现轻微的不匹配,并且比较失败.我们解决它的方法是设置比较选项,如下所示:

actual.ShouldBeEquivalentTo(expected,
        options =>
            options.Using<DateTime>(ctx => ctx.Subject.Should().BeCloseTo(ctx.Expectation))
                .WhenTypeIs<DateTime>());

有没有办法设置一次并让它始终适用,而不是每次调用ShouldBeEquivalentTo时都必须指定它？

Update1:​​尝试了以下方法,但它似乎不起作用,测试失败1毫秒的差异.工厂似乎没有调用新的默认值.

using System;
using FluentAssertions;
using FluentAssertions.Equivalency;
using Microsoft.VisualStudio.TestTools.UnitTesting;

namespace UnitTestProject1
{
    class Test
    {
        public DateTime TestDateTime { get; set; }
    }

    [TestClass]
    public class UnitTest1
    {
        [TestMethod]
        public void SettingFluentAssertionDefault()
        {
            // arrange
            var defaultAssertionOptions = EquivalencyAssertionOptions<DateTime>.Default;

            EquivalencyAssertionOptions<DateTime>.Default = () =>
            {
                var config = defaultAssertionOptions();
                config.Using<DateTime>(ctx => ctx.Subject.Should().BeCloseTo(ctx.Expectation)).WhenTypeIs<DateTime>();
                return config;
            };

            var testDateTime = DateTime.Now;
            var expected = new Test {TestDateTime = testDateTime};

            // act
            var actual …

我有一对列表,我试图使用Fluent断言进行比较.我可以轻松编写比较代码,但我想使用Fluent Assertions,以便我可以在测试失败消息中显示出来的原因.

到目前为止我看到的所有内容似乎都使用默认的Object.Equals比较,它区分大小写.我似乎无法将IComparer传递给Equal或Contains方法,那么还有其他方法吗？

[TestMethod()]
public void foo()
{
  var actual = new List<string> { "ONE", "TWO", "THREE", "FOUR" };
  var expected = new List<string> { "One", "Two", "Three", "Four" };

  actual.Should().Equal(expected);
}

当我使用 Fluent 断言来测试属性是否不为空时，分析器仍然会抱怨后续行取消引用该行可能为空。在使用 FluentAssertions 进行测试后，有什么方法可以让编译器将属性识别为不为空吗？例如

Foo? foo = Bar();

foo.Should().NotBeNull();
foo.Value.Should().Be(5); // Warning about dereference of a possibly null reference on this line

我知道我可以使用！在第二行的 foo 上，但是有什么方法可以让分析器自己解决这个问题吗？

我确实找到了这个，但我不知道如何在这种情况下使用它。