Flutter业务逻辑管理插件bloc_presentation_test的使用

bloc_presentation_test 是一个用于简化 BlocPresentationMixined Bloc/Cubit 测试的包。它与 bloc_presentation 包一起使用，以提供更直观的测试体验。

安装

首先，在项目的 pubspec.yaml 文件中添加 bloc_presentation_test 依赖项：

flutter pub add --dev bloc_presentation_test

使用方法

bloc_presentation_test 提供了两种方式来模拟 presentation 流：

1. 使用 whenListenPresentation 函数
2. 扩展目标 BlocPresentationMixined Bloc/Cubit 为 MockPresentationBloc/MockPresentationCubit

方法1 - whenListenPresentation

创建 Mock 类

首先，创建你的 BlocPresentationMixined Bloc/Cubit 的 mock 类。可以使用 bloc_test 包来实现这一点。

class MockCommentCubit extends MockCubit implements CommentCubit {}

获取 StreamController

然后，创建 MockCommentCubit 的实例，并通过调用 whenListenPresentation 来获取 StreamController。

final mockCubit = MockCommentCubit();
final controller = whenListenPresentation(mockCubit);

这将模拟 MockCommentCubit 的 presentation 流，你可以订阅这个流。获取到的控制器可以用来向 presentation 流添加事件。

controller.add(const FailedToUpvote());

如果你指定了 initialEvents 参数，presentation 流将被模拟成给定事件的流。

final controller = whenListenPresentation(
  mockCubit,
  const [FailedToUpvote(), SuccessfulUpvote()],
);

返回的 StreamController 在 Cubit/Bloc 的 close 方法中被释放。如果你重写了这个方法，则需要手动释放控制器。

方法2 - MockPresentationCubit/MockPresentationBloc

创建 Mock 类

首先，使用 MockPresentationBloc/MockPresentationCubit 创建你的 BlocPresentationMixined Bloc/Cubit 的 mock 类。

class MockCommentCubit extends MockPresentationCubit<CommentState> implements CommentCubit {}

发送模拟事件

然后，创建 MockCommentCubit 的实例并调用 emitMockPresentation。

final mockCubit = MockCommentCubit();
mockCubit.emitMockPresentation(const FailedToUpvote());

这将向 presentation 流添加 FailedToUpvoteEvent 事件。

最后，记得调用 MockCommentCubit 的 close 方法。

示例代码

下面是一个完整的示例，展示了如何使用 bloc_presentation_test 进行测试。

import 'dart:async';

import 'package:bloc/bloc.dart';
import 'package:bloc_presentation/bloc_presentation.dart';
import 'package:bloc_presentation_test/bloc_presentation_test.dart';
import 'package:bloc_test/bloc_test.dart';
import 'package:test/test.dart';

// 定义 CounterCubit
class CounterCubit extends Cubit<int> with BlocPresentationMixin<int, CounterCubitEvent> {
  CounterCubit() : super(0);

  void count() {
    final newNumber = state + 1;

    if (state < 10) {
      emitPresentation(CounterPresentationEvent(newNumber));
    }

    emit(newNumber);
  }
}

// 定义 CounterCubitEvent
sealed class CounterCubitEvent {}

final class CounterPresentationEvent implements CounterCubitEvent {
  const CounterPresentationEvent(this.number);

  final int number;

  @override
  int get hashCode => number.hashCode;

  @override
  bool operator ==(Object other) {
    if (identical(this, other)) return true;
    return other is CounterPresentationEvent && other.number == number;
  }
}

// 定义 MockCounterPresentationCubit
class MockCounterPresentationCubit extends MockPresentationCubit<int, CounterCubitEvent> implements CounterCubit {}

// 定义 MockCounterCubit
class MockCounterCubit extends MockCubit<int> implements CounterCubit {}

void main() {
  mainMockPresentationCubit();
  mainWhenListenPresentation();
  mainBlocPresentationTest();
}

void mainMockPresentationCubit() {
  late MockCounterPresentationCubit mockCubit;

  setUp(() {
    mockCubit = MockCounterPresentationCubit();
  });

  tearDown(() {
    mockCubit.close();
  });

  test('presentation stream emits events properly', () async {
    mockCubit.emitMockPresentation(const CounterPresentationEvent(5));

    await expectLater(
      mockCubit.presentation,
      emitsInOrder([
        equals(const CounterPresentationEvent(5)),
      ]),
    );
  });
}

void mainWhenListenPresentation() {
  late MockCounterCubit mockCubit;
  late StreamController<CounterCubitEvent> controller;

  setUp(() {
    mockCubit = MockCounterCubit();
    controller = whenListenPresentation(
      mockCubit,
      initialEvents: [const CounterPresentationEvent(1)],
    );
  });

  tearDown(() {
    mockCubit.close();
  });

  test('presentation stream emits events properly', () async {
    controller.add(const CounterPresentationEvent(2));

    await expectLater(
      mockCubit.presentation,
      emitsInOrder([
        equals(const CounterPresentationEvent(1)),
        equals(const CounterPresentationEvent(2)),
      ]),
    );
  });
}

void mainBlocPresentationTest() {
  CounterCubit buildCubit() => CounterCubit();

  blocPresentationTest<CounterCubit, int, CounterCubitEvent>(
    'emits correct presentation event after calling count when state was smaller than 10',
    build: buildCubit,
    act: (cubit) => cubit.count(),
    expectPresentation: () => const [
      CounterPresentationEvent(1),
    ],
  );

  blocPresentationTest<CounterCubit, int, CounterCubitEvent>(
    'does not emit presentation event if count has not been called',
    build: buildCubit,
    expectPresentation: () => const <CounterPresentationEvent>[],
  );

  blocPresentationTest<CounterCubit, int, CounterCubitEvent>(
    'emits correct presentation event after calling count 2 times when state was smaller than 10',
    build: buildCubit,
    act: (cubit) => cubit..count()..count(),
    skipPresentation: 1,
    expectPresentation: () => const [
      CounterPresentationEvent(2),
    ],
  );

  blocPresentationTest<CounterCubit, int, CounterCubitEvent>(
    'does not emit presentation event after calling count when state was 10',
    build: buildCubit,
    seed: () => 10,
    act: (cubit) => cubit.count(),
    expectPresentation: () => const <CounterPresentationEvent>[],
  );
}

这个示例展示了如何使用 bloc_presentation_test 来测试带有 BlocPresentationMixin 的 Cubit。你可以根据需要调整和扩展这些测试用例，以适应你自己的业务逻辑。