chore: rebasing

lib/game/pinball_game.dart

@@ -54,10 +54,13 @@ class PinballGame extends Forge2DGame
         camera.viewport.effectiveSize.y / 1.1,
       ),
     );
-    await add(
+
-      FlipperGroup(
+    unawaited(
-        position: flippersPosition,
+      add(
-        spacing: 2,
+        FlipperGroup(
+          position: flippersPosition,
+          spacing: 2,
+        ),
       ),
     );
   }

test/game/components/flipper_test.dart

@@ -2,6 +2,7 @@
 
 import 'dart:collection';
 
+import 'package:flame/components.dart';
 import 'package:flame_forge2d/flame_forge2d.dart';
 import 'package:flame_test/flame_test.dart';
 import 'package:flutter/services.dart';
@@ -13,6 +14,104 @@ import '../../helpers/helpers.dart';
 void main() {
   TestWidgetsFlutterBinding.ensureInitialized();
   final flameTester = FlameTester(PinballGameTest.create);
+
+  group('FlipperGroup', () {
+    flameTester.test(
+      'loads correctly',
+      (game) async {
+        final flipperGroup = FlipperGroup(
+          position: Vector2.zero(),
+          spacing: 0,
+        );
+        await game.ensureAdd(flipperGroup);
+
+        expect(game.contains(flipperGroup), isTrue);
+      },
+    );
+
+    group('constructor', () {
+      flameTester.test(
+        'positions correctly',
+        (game) async {
+          final position = Vector2.all(10);
+          final flipperGroup = FlipperGroup(
+            position: position,
+            spacing: 0,
+          );
+          await game.ensureAdd(flipperGroup);
+
+          expect(flipperGroup.position, equals(position));
+        },
+      );
+    });
+
+    group('children', () {
+      bool Function(Component) flipperSelector(BoardSide side) =>
+          (component) => component is Flipper && component.side == side;
+      flameTester.test(
+        'has only one left Flipper',
+        (game) async {
+          final flipperGroup = FlipperGroup(
+            position: Vector2.zero(),
+            spacing: 0,
+          );
+          await game.ensureAdd(flipperGroup);
+
+          expect(
+            () => flipperGroup.children.singleWhere(
+              flipperSelector(BoardSide.left),
+            ),
+            returnsNormally,
+          );
+        },
+      );
+
+      flameTester.test(
+        'has only one right Flipper',
+        (game) async {
+          final flipperGroup = FlipperGroup(
+            position: Vector2.zero(),
+            spacing: 0,
+          );
+          await game.ensureAdd(flipperGroup);
+
+          expect(
+            () => flipperGroup.children.singleWhere(
+              flipperSelector(BoardSide.right),
+            ),
+            returnsNormally,
+          );
+        },
+      );
+
+      flameTester.test(
+        'spaced correctly',
+        (game) async {
+          final flipperGroup = FlipperGroup(
+            position: Vector2.zero(),
+            spacing: 2,
+          );
+          await game.ready();
+          await game.ensureAdd(flipperGroup);
+
+          final leftFlipper = flipperGroup.children.singleWhere(
+            flipperSelector(BoardSide.left),
+          ) as Flipper;
+          final rightFlipper = flipperGroup.children.singleWhere(
+            flipperSelector(BoardSide.right),
+          ) as Flipper;
+
+          expect(
+            leftFlipper.body.position.x +
+                leftFlipper.size.x +
+                flipperGroup.spacing,
+            equals(rightFlipper.body.position.x),
+          );
+        },
+      );
+    });
+  });
+
   group(
     'Flipper',
     () {
@@ -21,9 +120,11 @@ void main() {
         (game) async {
           final leftFlipper = Flipper.left(position: Vector2.zero());
           final rightFlipper = Flipper.right(position: Vector2.zero());
+          await game.ready();
           await game.ensureAddAll([leftFlipper, rightFlipper]);
 
           expect(game.contains(leftFlipper), isTrue);
+          expect(game.contains(rightFlipper), isTrue);
         },
       );
 

test/game/pinball_game_test.dart

@@ -18,72 +18,40 @@ void main() {
     // [BallScorePointsCallback] once the following issue is resolved:
     // https://github.com/flame-engine/flame/issues/1416
     group('components', () {
-      group('Walls', () {
+      bool Function(Component) componentSelector<T>() =>
-        flameTester.test(
+          (component) => component is T;
-          'has three Walls',
-          (game) async {
-            await game.ready();
-            final walls = game.children
-                .where(
-                  (component) => component is Wall && component is! BottomWall,
-                )
-                .toList();
-            // TODO(allisonryan0002): expect 3 when launch track is added and
-            // temporary wall is removed.
-            expect(walls.length, 4);
-          },
-        );
 
-        flameTester.test(
+      flameTester.test(
-          'has only one BottomWall',
+        'has three Walls',
-          (game) async {
+        (game) async {
-            await game.ready();
+          await game.ready();
-
+          final walls = game.children
-            expect(
+              .where(
-              () => game.children.singleWhere(
+                (component) => component is Wall && component is! BottomWall,
-                (component) => component is BottomWall,
+              )
-              ),
+              .toList();
-              returnsNormally,
+          // TODO(allisonryan0002): expect 3 when launch track is added and
-            );
+          // temporary wall is removed.
-          },
+          expect(walls.length, 4);
-        );
+        },
-      });
+      );
 
-      group('Flippers', () {
+      flameTester.test(
-        bool Function(Component) flipperSelector(BoardSide side) =>
+        'has only one BottomWall',
-            (component) => component is Flipper && component.side == side;
+        (game) async {
-
+          await game.ready();
-        flameTester.test(
-          'has only one left Flipper',
-          (game) async {
-            await game.ready();
-
-            expect(
-              () => game.children.singleWhere(
-                flipperSelector(BoardSide.left),
-              ),
-              returnsNormally,
-            );
-          },
-        );
 
-        flameTester.test(
+          expect(
-          'has only one right Flipper',
+            () => game.children.singleWhere(
-          (game) async {
+              componentSelector<BottomWall>(),
-            await game.ready();
+            ),
-
+            returnsNormally,
-            expect(
+          );
-              () => game.children.singleWhere(
+        },
-                flipperSelector(BoardSide.right),
+      );
-              ),
-              returnsNormally,
-            );
-          },
-        );
-      });
 
       flameTester.test(
-        'Plunger has only one Plunger',
+        'has only one Plunger',
         (game) async {
           await game.ready();
 
@@ -95,6 +63,17 @@ void main() {
           );
         },
       );
+
+      flameTester.test('has only one FlipperGroup', (game) async {
+        await game.ready();
+
+        expect(
+          () => game.children.singleWhere(
+            (component) => component is FlipperGroup,
+          ),
+          returnsNormally,
+        );
+      });
     });
 
     debugModeFlameTester.test('adds a ball on tap up', (game) async {