BlocObserver testing capability proposal

packages/bloc_test/lib/src/bloc_test.dart

@@ -148,6 +148,7 @@ void blocTest<B extends BlocBase<State>, State>(
   dynamic Function(B bloc)? verify,
   dynamic Function()? errors,
   FutureOr<void> Function()? tearDown,
+  BlocObserver? observer,
   dynamic tags,
 }) {
   test.test(
@@ -164,6 +165,7 @@ void blocTest<B extends BlocBase<State>, State>(
         verify: verify,
         errors: errors,
         tearDown: tearDown,
+        observer: observer,
       );
     },
     tags: tags,
@@ -184,10 +186,12 @@ Future<void> testBloc<B extends BlocBase<State>, State>({
   dynamic Function(B bloc)? verify,
   dynamic Function()? errors,
   FutureOr<void> Function()? tearDown,
+  BlocObserver? observer,
 }) async {
   var shallowEquality = false;
   final unhandledErrors = <Object>[];
-  final localBlocObserver = Bloc.observer;
+  final firstObserver = Bloc.observer;
+  final localBlocObserver = observer ?? Bloc.observer;
   final testObserver = _TestBlocObserver(
     localBlocObserver,
     unhandledErrors.add,
@@ -206,7 +210,9 @@ Future<void> testBloc<B extends BlocBase<State>, State>({
         await act?.call(bloc);
       } catch (error) {
         if (errors == null) rethrow;
-        unhandledErrors.add(error);
+        if (!unhandledErrors.contains(error)) {
+          unhandledErrors.add(error);
+        }
       }
       if (wait != null) await Future<void>.delayed(wait);
       await Future<void>.delayed(Duration.zero);
@@ -241,6 +247,8 @@ Alternatively, consider using Matchers in the expect of the blocTest rather than
     if (errors == null || !unhandledErrors.contains(error)) {
       rethrow;
     }
+  } finally {
+    Bloc.observer = firstObserver;
   }
 
   if (errors != null) test.expect(unhandledErrors, test.wrapMatcher(errors()));
@@ -269,6 +277,37 @@ class _TestBlocObserver extends BlocObserver {
     _onError(error);
     super.onError(bloc, error, stackTrace);
   }
+
+  @override
+  void onChange(BlocBase<dynamic> bloc, Change<dynamic> change) {
+    _localObserver.onChange(bloc, change);
+    super.onChange(bloc, change);
+  }
+
+  @override
+  void onClose(BlocBase<dynamic> bloc) {
+    _localObserver.onClose(bloc);
+    super.onClose(bloc);
+  }
+
+  @override
+  void onCreate(BlocBase<dynamic> bloc) {
+    _localObserver.onCreate(bloc);
+    super.onCreate(bloc);
+  }
+
+  @override
+  void onEvent(Bloc<dynamic, dynamic> bloc, Object? event) {
+    _localObserver.onEvent(bloc, event);
+    super.onEvent(bloc, event);
+  }
+
+  @override
+  void onTransition(
+      Bloc<dynamic, dynamic> bloc, Transition<dynamic, dynamic> transition) {
+    _localObserver.onTransition(bloc, transition);
+    super.onTransition(bloc, transition);
+  }
 }
 
 String _diff({required dynamic expected, required dynamic actual}) {

packages/bloc_test/test/bloc_bloc_test_test.dart

@@ -5,6 +5,7 @@ import 'package:mocktail/mocktail.dart';
 import 'package:test/test.dart';
 
 import 'blocs/blocs.dart';
+import 'blocs/failing_observer.dart';
 
 class MockRepository extends Mock implements Repository {}
 
@@ -662,6 +663,32 @@ Alternatively, consider using Matchers in the expect of the blocTest rather than
       });
     });
   });
+  group('BlocObservers', () {
+    test(
+      'FailingObserver',
+      () async {
+        Object? actualError;
+        final completer = Completer<void>();
+        await runZonedGuarded(() async {
+          unawaited(
+            testBloc<CounterBloc, int>(
+              build: () => CounterBloc(),
+              act: (bloc) => bloc.add(CounterEvent.increment),
+              errors: () => [isA<StateError>()],
+              observer: FailingObserver(),
+            ).then((_) {
+              completer.complete();
+            }),
+          );
+          await completer.future;
+        }, (Object error, _) {
+          actualError = error;
+          if (!completer.isCompleted) completer.complete();
+        });
+        expect(actualError, isNull);
+      },
+    );
+  });
 
   group('tearDown', () {
     late int tearDownCallCount;

packages/bloc_test/test/blocs/failing_observer.dart

@@ -0,0 +1,9 @@
+import 'package:bloc/bloc.dart';
+
+class FailingObserver extends BlocObserver {
+  @override
+  void onEvent(Bloc<dynamic, dynamic> bloc, Object? event) {
+    super.onEvent(bloc, event);
+    throw StateError('catch me');
+  }
+}