Question

从昨天的问题继续，我将如何测试异步方法抛出异常。

main(){
  test( "test2", () async {
    expect( await throws(), throwsException);
  });

}

Future throws () async {
  throw new FormatException("hello");
}

Answer 1

使用try-catch

最可靠的方法是使用 try-catch 块来显式捕获异常并确保方法已完成运行。

try {
    await methodWhichThrows();
    fail("exception not thrown");
} catch (e) {
    expect(e, new isInstanceOf<...>());
    // more expect statements can go here
}

这种方法还有一个优点，即可以对异常值进行额外的检查。

使用throwsA的预期仅作为最后一个声明

使用 expect 仅在测试中是 last 语句时才有效。当方法抛出异常时，无法控制，因此可能存在与语句竞争的条件（包括后续调用 expect ），如果他们认为异常有已被抛出。

expect(methodWhichThrows(), throwsA(new isInstanceOf<...>())); // unreliable unless last

可以使用它，但你必须非常小心地记住它在哪种情况下工作，哪些情况不适用。因此，坚持使用 try-catch 方法更安全，而不是针对不同情况使用不同的方法。

<强>示范

以下完整示例演示了竞争条件对两种方法的影响：

import 'dart:async'; import 'package:test/test.dart'; //---------------------------------------------------------------- /// This approach to expecting exceptions is reliable. /// Future reliableApproach(int luck) async { expect(await setValueAndReturnsHalf(42), equals(21)); expect(state, equals(Evenness.isEven)); try { await setValueAndReturnsHalf(3); fail("exception not thrown"); } catch (e) { expect(e, new isInstanceOf<ArgumentError>()); } // Expect value to be odd after execption is thrown. await shortDelay(luck); // in my experience there's no such thing called luck expect(state, equals(Evenness.isOdd)); } //---------------------------------------------------------------- /// This approach to expecting exceptions is unreliable. /// Future unreliableApproach(int luck) async { expect(await setValueAndReturnsHalf(42), equals(21)); expect(state, equals(Evenness.isEven)); expect(setValueAndReturnsHalf(3), throwsA(new isInstanceOf<ArgumentError>())); // Expect value to be odd after execption is thrown. await shortDelay(luck); // luck determines if the race condition is triggered expect(state, equals(Evenness.isOdd)); } //---------------------------------------------------------------- enum Evenness { isEven, isOdd, inLimbo } int value = 0; Evenness state = Evenness.isEven; /// Sets the [value] and [state]. /// /// If the [newValue] is even, [state] is set to [Evenness.isEven] and half of it /// is returned as the Future's value. /// /// If the [newValue] is odd, [state] is set to [Evenness.isOdd] and an exception /// is thrown. /// /// To simulate race conditions, this method takes 2 seconds before it starts /// processing and 4 seconds to succeed or throw an exception. While it is /// processing, the [state] is set to [Evenness.inLimbo]. /// Future<int> setValueAndReturnsHalf(int newValue) async { await shortDelay(2); state = Evenness.inLimbo; await shortDelay(2); value = newValue; if (newValue % 2 != 0) { state = Evenness.isOdd; throw new ArgumentError.value(newValue, "value", "is not an even number"); } else { state = Evenness.isEven; return value ~/ 2; } } /// Delays used to simulate processing and race conditions. /// Future shortDelay(int seconds) { var c = new Completer(); new Timer(new Duration(seconds: seconds), () => c.complete()); return c.future; } /// Examples of the reliable and unreliable approaches. /// void main() { test("Correct operation when exception is not thrown", () async { expect(await setValueAndReturnsHalf(42), equals(21)); expect(value, equals(42)); }); group("Reliable approach:", () { test("works when there is bad luck", () async { // 1 second = bad luck, future returning function not started processing yet await reliableApproach(1); }); test("works when there is more bad luck", () async { // 3 second = bad luck, future returning function still processing await reliableApproach(3); }); test("works when there is good luck", () async { // 5 seconds = good luck, future returning function definitely finished await reliableApproach(5); }); }); group("Unreliable approach:", () { test("race condition encountered by bad luck", () async { // 1 second = bad luck, future returning function not started processing yet await unreliableApproach(1); }); test("race condition encountered by more bad luck", () async { // 3 second = bad luck, future returning function still processing await unreliableApproach(3); }); test("race condition avoided by good luck", () async { // 5 seconds = good luck, future returning function definitely finished await unreliableApproach(5); }); }); }

Answer 2

这种方式有效：

import 'package:test/test.dart';
import 'dart:async';

void main() {
  test( "test2", ()  { // with or without `async`
    expect(throws(), throwsA(const TypeMatcher<FormatException>()));
  });
}

Future throws () async {
  throw new FormatException("hello");
}

基本上只需删除await即可。无论成功还是失败，测试框架都可以处理期货。

Answer 3

有多种方法可以测试来自Future的错误。如果没有异步的话，Gunter的回答将起作用＃34;方法是抛出一些异常。下面的示例将处理来自未来方法的异常。

import 'package:test/test.dart';
import 'dart:async';

void main() {
    test("test with Zone", () {
        runZoned(() {
            throws();
        }, onError: expectAsync((e, s) {
            expect(e, new isInstanceOf<FormatException>());
        }));
    });

    test('test with future catch error', () {
        throws().catchError(expectAsync((e) {
            expect(e, new isInstanceOf<FormatException>());
        }));
    });
}

Future throws() async{
    Completer completer = new Completer();
    completer.complete(new Future(() => throw new FormatException("hello")));
    return completer.future;
}

Answer 4

最简单，最简短的答案是：

expect(throws(), throwsException)

要测试异常/错误类型：

expect(throws(), throwsA(predicate((e) => e is MyException)));

Answer 5

经过多次尝试和错误后，我发现这个可以正常工作：

  test('fetch SHOULD throw exception WHEN api fail with exception', () {
      when(clientMock.get(uri)).thenAnswer((_) async => throw Exception());

      expect(() => sut.fetch(), throwsA(isInstanceOf<Exception>()));

});

如何测试未来的异常

5 个答案: