Flutter异步测试辅助插件bloc_test_async的使用

Flutter异步测试辅助插件bloc_test_async的使用

bloc_test_async 是一个用于测试异步操作的 bloc 扩展插件。它通过等待事件完成来替代使用静态的 wait 参数，从而使得测试更加灵活和可靠。

问题

bloc_test 提供了一个 wait 参数来延迟执行 expect 块以测试异步操作。但是，当异步操作所需时间超过 wait 持续时间时，测试会失败，因为所有在 expected 中定义的状态没有按时被发出。

因此，wait 参数需要设置为一个静态的、估计的时间。这在任何影响实际持续时间的变化发生时都可能需要调整 wait 参数，这带来了问题。

解决方案

使用 bloc_test_async 包来弃用 wait 参数，并改用等待事件完成的方式。这样可以更准确地测试异步操作。

blocTest("ExampleBloc",
    build: () => ExampleBloc(),
    act: (bloc) async {
      await bloc.addToComplete(ExampleEvent());
    },
    expect: () => [ExampleLoadingState(), ExampleSuccessState()]);

addToComplete 扩展方法向 bloc 添加一个事件，并返回一个 Future 来等待该事件在 bloc 中完成。因此，不需要 wait 参数，因为可以确保在 act 块中添加的事件已经完成。

迁移指南

添加依赖

在 pubspec.yaml 文件中添加 bloc_test_async 依赖：

dependencies:
  bloc_test_async: ^0.1.0

修改Bloc实现

你的 bloc 实现需要进行调整以便使用 addToComplete 方法。只需将 on 方法替换为 completeOn：

class MyBloc extends Bloc<Event, State> {
  MyBloc() : super(Initial()) {
    // 替换之前的 on&lt;Event&gt;((event, emit)
    completeOn&lt;Event&gt;((event, emit) async {
      emit(Loading());
      // 执行一些操作
      emit(Success());
    });
  }
}

当 completeOn 在非测试环境中运行时，会跳过事件完成的信号处理逻辑，行为类似于 on 方法。

修改blocTest

在 blocTest 中，如果需要，可以删除 wait 参数，并使用 await addToComplete() 替换 add() 方法。act 块必须定义为 async 以使用 await。

blocTest("MyBloc",
    build: () => MyBloc(),
    act: (bloc) async {
      // 替换之前的 bloc.add(Event())
      await bloc.addToComplete(Event());
    },
    expect: () => [Loading(), Success()]);

当 addToComplete 在非测试环境中使用时，会抛出异常。

超时处理

addToComplete 方法提供了 timeout 参数来定义事件完成的超时时间。

blocTest("MyBloc",
    build: () => MyBloc(),
    act: (bloc) async {
      await bloc.addToComplete(Event(), timeout: Duration(seconds: 3));
    },
    expect: () => [Loading(), Success()]);

默认情况下，超时时间为 5 秒。如果超时发生，则会抛出 TimeoutException 并导致测试失败。

完整示例

以下是一个完整的示例代码，展示了如何使用 bloc_test_async 插件进行异步测试：

import 'dart:math';

import 'package:bloc/bloc.dart';
import 'package:bloc_test/bloc_test.dart';
import 'package:bloc_test_async/bloc_test_async.dart';
import 'package:equatable/equatable.dart';

// 定义事件类型
class RandomDelayEvent {}

// 定义状态类型
sealed class State extends Equatable {
  [@override](/user/override)
  List<Object?> get props => [];
}

class Initial extends State {}

class Loading extends State {}

class Success extends State {}

// 定义Bloc类
class RandomDelayBloc extends Bloc<RandomDelayEvent, State> {
  RandomDelayBloc() : super(Initial()) {
    // 使用completeOn替换on方法
    completeOn<RandomDelayEvent>((event, emit) async {
      emit(Loading());

      // 随机生成一个延迟时间
      Duration delay = Duration(milliseconds: Random().nextInt(2000));
      await Future.delayed(delay);

      emit(Success());
    });
  }
}

void main() {
  // 使用blocTest进行测试
  blocTest("RandomDelayBloc",
      build: () => RandomDelayBloc(),
      act: (bloc) async {
        await bloc.addToComplete(RandomDelayEvent());
      },
      expect: () => [Loading(), Success()]);
}