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