继续昨天的问题,我将如何测试异步方法是否引发异常。
main(){
test( "test2", () async {
expect( await throws(), throwsException);
});
}
Future throws () async {
throw new FormatException("hello");
}
继续昨天的问题,我将如何测试异步方法是否引发异常。
main(){
test( "test2", () async {
expect( await throws(), throwsException);
});
}
Future throws () async {
throw new FormatException("hello");
}
使用 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 仅用作最后一条语句
仅当它是测试中的最后一条语句时,单独使用expect才有效。无法控制该方法何时抛出异常,因此如果假设已经抛出异常,则语句(包括对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);
});
});
}
这样它的工作原理:
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
. 测试框架可以处理未来,无论它们是成功还是失败。
最简单和最短的答案是:
expect(throws(), throwsException)
测试异常/错误类型:
expect(throws(), throwsA(predicate((e) => e is MyException)));
经过太多的尝试和错误,我发现这个按预期工作:
test('fetch SHOULD throw exception WHEN api fail with exception', () {
when(clientMock.get(uri)).thenAnswer((_) async => throw Exception());
expect(() => sut.fetch(), throwsA(isInstanceOf < Exception > ()));
});
有多种方法可以测试来自 Future 的错误。如果“ throws without async”方法抛出一些异常,Gunter 的答案将起作用。下面的示例将处理来自未来方法的异常。
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;
}