fix: fixed bloc bug for tests on multiplier behavior

lib/game/components/multipliers/behaviors/multipliers_behavior.dart

@@ -1,27 +1,25 @@
 import 'package:flame/components.dart';
+import 'package:flame_bloc/flame_bloc.dart';
 import 'package:pinball/game/game.dart';
 import 'package:pinball_components/pinball_components.dart';
 import 'package:pinball_flame/pinball_flame.dart';
 
 /// Toggle each [Multiplier] when GameState.multiplier changes.
 class MultipliersBehavior extends Component
-    with HasGameRef<PinballGame>, ParentIsA<Multipliers> {
+    with
+        HasGameRef<PinballGame>,
+        ParentIsA<Multipliers>,
+        BlocComponent<GameBloc, GameState> {
   @override
-  void onMount() {
+  bool listenWhen(GameState? previousState, GameState newState) {
-    super.onMount();
+    return previousState?.multiplier != newState.multiplier;
-
+  }
-    var previousMultiplier = 1;
-
-    // TODO(ruimiguel): filter only when multiplier has change.
-    gameRef.read<GameBloc>().stream.listen((state) {
-      if (state.multiplier != previousMultiplier) {
-        previousMultiplier = state.multiplier;
 
+  @override
+  void onNewState(GameState state) {
     final multipliers = parent.children.whereType<Multiplier>();
     for (final multiplier in multipliers) {
       multiplier.bloc.next(state.multiplier);
     }
   }
-    });
-  }
 }

test/game/components/multipliers/behaviors/multipliers_behavior_test.dart

@@ -46,43 +46,79 @@ void main() {
       assets: assets,
     );
 
+    group('listenWhen', () {
+      test('is true when the multiplier has changed', () {
+        final state = GameState(
+          score: 10,
+          multiplier: 2,
+          rounds: 0,
+          bonusHistory: const [],
+        );
+
+        final previous = GameState.initial();
+        expect(
+          MultipliersBehavior().listenWhen(previous, state),
+          isTrue,
+        );
+      });
+
+      test('is false when the multiplier state is the same', () {
+        final state = GameState(
+          score: 10,
+          multiplier: 1,
+          rounds: 0,
+          bonusHistory: const [],
+        );
+
+        final previous = GameState.initial();
+        expect(
+          MultipliersBehavior().listenWhen(previous, state),
+          isFalse,
+        );
+      });
+
       flameBlocTester.testGameWidget(
         "calls 'next' once per each multiplier when GameBloc emit state",
         setUp: (game, tester) async {
-        final multiplierCubit = MockMultiplierCubit();
           final behavior = MultipliersBehavior();
           final parent = Multipliers.test();
+          final multiplierX2Cubit = MockMultiplierCubit();
+          final multiplierX3Cubit = MockMultiplierCubit();
           final multipliers = [
             Multiplier.test(
               value: MultiplierValue.x2,
-            bloc: multiplierCubit,
+              bloc: multiplierX2Cubit,
+            ),
+            Multiplier.test(
+              value: MultiplierValue.x3,
+              bloc: multiplierX3Cubit,
             ),
           ];
 
           whenListen(
-          multiplierCubit,
+            multiplierX2Cubit,
             const Stream<MultiplierState>.empty(),
-          initialState: MultiplierState(
+            initialState: MultiplierState.initial(MultiplierValue.x2),
-            value: MultiplierValue.x2,
-            spriteState: MultiplierSpriteState.dimmed,
-          ),
           );
+          when(() => multiplierX2Cubit.next(any())).thenAnswer((_) async {});
 
-        final streamController = StreamController<GameState>();
           whenListen(
-          gameBloc,
+            multiplierX3Cubit,
-          streamController.stream,
+            const Stream<MultiplierState>.empty(),
-          initialState: GameState.initial(),
+            initialState: MultiplierState.initial(MultiplierValue.x2),
           );
+          when(() => multiplierX3Cubit.next(any())).thenAnswer((_) async {});
 
           await parent.addAll(multipliers);
           await game.ensureAdd(parent);
           await parent.ensureAdd(behavior);
 
-        streamController.add(GameState.initial().copyWith(multiplier: 2));
-
           await tester.pump();
 
+          behavior.onNewState(
+            GameState.initial().copyWith(multiplier: 2),
+          );
+
           for (final multiplier in multipliers) {
             verify(
               () => multiplier.bloc.next(any()),
@@ -91,4 +127,5 @@ void main() {
         },
       );
     });
+  });
 }