fix(bloc_test)!: forward _TestBlocObserver events to localObserver

packages/bloc_test/lib/src/bloc_test.dart

@@ -260,12 +260,56 @@ class _TestBlocObserver extends BlocObserver {
   final BlocObserver _localObserver;
   final void Function(Object error) _onError;
 
+  @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 onChange(BlocBase<dynamic> bloc, Change<dynamic> change) {
+    _localObserver.onChange(bloc, change);
+    super.onChange(bloc, change);
+  }
+
+  @override
+  void onTransition(
+    Bloc<dynamic, dynamic> bloc,
+    Transition<dynamic, dynamic> transition,
+  ) {
+    _localObserver.onTransition(bloc, transition);
+    super.onTransition(bloc, transition);
+  }
+
   @override
   void onError(BlocBase<dynamic> bloc, Object error, StackTrace stackTrace) {
     _localObserver.onError(bloc, error, stackTrace);
     _onError(error);
     super.onError(bloc, error, stackTrace);
   }
+
+  @override
+  void onDone(
+    Bloc<dynamic, dynamic> bloc,
+    Object? event, [
+    Object? error,
+    StackTrace? stackTrace,
+  ]) {
+    _localObserver.onDone(bloc, event, error, stackTrace);
+    super.onDone(bloc, event, error, stackTrace);
+  }
+
+  @override
+  void onClose(BlocBase<dynamic> bloc) {
+    _localObserver.onClose(bloc);
+    super.onClose(bloc);
+  }
 }
 
 String _diff({required dynamic expected, required dynamic actual}) {

packages/bloc_test/pubspec.yaml

@@ -12,7 +12,7 @@ environment:
   sdk: ">=2.14.0 <4.0.0"
 
 dependencies:
-  bloc: ^9.0.0
+  bloc: ^9.1.0
   diff_match_patch: ^0.4.1
   meta: ^1.3.0
   mocktail: ^1.0.0

packages/bloc_test/test/bloc_observer_test.dart

@@ -0,0 +1,110 @@
+import 'package:bloc/bloc.dart';
+import 'package:bloc_test/bloc_test.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:test/test.dart';
+
+import 'blocs/counter_bloc.dart';
+import 'blocs/exception_counter_bloc.dart';
+
+class _MockBlocObserver extends Mock implements BlocObserver {}
+
+void main() {
+  group('BlocObserver', () {
+    late BlocObserver blocObserver;
+
+    setUp(() {
+      blocObserver = _MockBlocObserver();
+      final previousObserver = Bloc.observer;
+      addTearDown(() => Bloc.observer = previousObserver);
+      Bloc.observer = blocObserver;
+    });
+
+    blocTest<CounterBloc, int>(
+      'calls onCreate',
+      build: () => CounterBloc(),
+      verify: (bloc) {
+        // ignore: invalid_use_of_protected_member
+        verify(() => blocObserver.onCreate(bloc)).called(1);
+      },
+    );
+
+    blocTest<CounterBloc, int>(
+      'calls onEvent',
+      build: () => CounterBloc(),
+      act: (bloc) => bloc.add(CounterEvent.increment),
+      verify: (bloc) {
+        verify(
+          // ignore: invalid_use_of_protected_member
+          () => blocObserver.onEvent(bloc, CounterEvent.increment),
+        ).called(1);
+      },
+    );
+
+    blocTest<CounterBloc, int>(
+      'calls onChange',
+      build: () => CounterBloc(),
+      act: (bloc) => bloc.add(CounterEvent.increment),
+      verify: (bloc) {
+        const change = Change<int>(currentState: 0, nextState: 1);
+        // ignore: invalid_use_of_protected_member
+        verify(() => blocObserver.onChange(bloc, change)).called(1);
+      },
+    );
+
+    blocTest<CounterBloc, int>(
+      'calls onTransition',
+      build: () => CounterBloc(),
+      act: (bloc) => bloc.add(CounterEvent.increment),
+      verify: (bloc) {
+        const transition = Transition<CounterEvent, int>(
+          event: CounterEvent.increment,
+          currentState: 0,
+          nextState: 1,
+        );
+        // ignore: invalid_use_of_protected_member
+        verify(() => blocObserver.onTransition(bloc, transition)).called(1);
+      },
+    );
+
+    blocTest<ExceptionCounterBloc, int>(
+      'calls onError',
+      build: () => ExceptionCounterBloc(),
+      act: (bloc) => bloc.add(CounterEvent.increment),
+      setUp: () {
+        registerFallbackValue(StackTrace.empty);
+      },
+      verify: (bloc) {
+        verify(
+          // ignore: invalid_use_of_protected_member
+          () => blocObserver.onError(
+            bloc,
+            ExceptionCounterBlocException(),
+            any(),
+          ),
+        ).called(1);
+      },
+      errors: () => containsOnce(isA<ExceptionCounterBlocException>()),
+    );
+
+    blocTest<CounterBloc, int>(
+      'calls onDone',
+      build: () => CounterBloc(),
+      act: (bloc) => bloc.add(CounterEvent.increment),
+      verify: (bloc) {
+        verify(
+          // ignore: invalid_use_of_protected_member
+          () => blocObserver.onDone(bloc, CounterEvent.increment),
+        ).called(1);
+      },
+    );
+
+    blocTest<CounterBloc, int>(
+      'calls onClose',
+      build: () => CounterBloc(),
+      verify: (bloc) {
+        // ignore: invalid_use_of_protected_member
+        verify(() => blocObserver.onClose(bloc)).called(1);
+      },
+    );
+  });
+}