Adding Flame test use case methods (#963)

* Adding Flame test use case methods

* Update packages/flame_test/lib/src/flame_test.dart

* Update packages/flame_test/lib/src/flame_test.dart

* Update packages/flame_test/CHANGELOG.md

* Update packages/flame_test/example/lib/game.dart

packages/flame/.min_coverage

@@ -1 +1 @@
-59.4
+61.7

packages/flame/test/game/game_widget/game_widget_drag_test.dart

@@ -0,0 +1,97 @@
+import 'package:flame/game.dart';
+import 'package:flame/input.dart';
+import 'package:flame_test/flame_test.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+class HorizontalDragGame extends FlameGame with HorizontalDragDetector {
+  bool horizontalDragStarted = false;
+  bool horizontalDragEnded = false;
+
+  @override
+  void onHorizontalDragStart(_) {
+    horizontalDragStarted = true;
+  }
+
+  @override
+  void onHorizontalDragEnd(_) {
+    horizontalDragEnded = true;
+  }
+}
+
+class VerticalDragGame extends FlameGame with VerticalDragDetector {
+  bool verticalDragStarted = false;
+  bool verticalDragEnded = false;
+
+  @override
+  void onVerticalDragStart(_) {
+    verticalDragStarted = true;
+  }
+
+  @override
+  void onVerticalDragEnd(_) {
+    verticalDragEnded = true;
+  }
+}
+
+class PanGame extends FlameGame with PanDetector {
+  bool panStarted = false;
+  bool panEnded = false;
+
+  @override
+  void onPanStart(_) {
+    panStarted = true;
+  }
+
+  @override
+  void onPanEnd(_) {
+    panEnded = true;
+  }
+}
+
+void main() {
+  group('GameWidget - HorizontalDragDetector', () {
+    flameWidgetTest<HorizontalDragGame>(
+      'register drags',
+      createGame: () => HorizontalDragGame(),
+      verify: (game, tester) async {
+        await tester.drag(
+          find.byGame<HorizontalDragGame>(),
+          const Offset(50, 0),
+        );
+
+        expect(game.horizontalDragStarted, isTrue);
+        expect(game.horizontalDragEnded, isTrue);
+      },
+    );
+  });
+  group('GameWidget - VerticallDragDetector', () {
+    flameWidgetTest<VerticalDragGame>(
+      'register drags',
+      createGame: () => VerticalDragGame(),
+      verify: (game, tester) async {
+        await tester.drag(
+          find.byGame<VerticalDragGame>(),
+          const Offset(50, 0),
+        );
+
+        expect(game.verticalDragStarted, isTrue);
+        expect(game.verticalDragEnded, isTrue);
+      },
+    );
+  });
+  group('GameWidget - PanDetector', () {
+    flameWidgetTest<PanGame>(
+      'register drags',
+      createGame: () => PanGame(),
+      verify: (game, tester) async {
+        await tester.drag(
+          find.byGame<PanGame>(),
+          const Offset(50, 0),
+        );
+
+        expect(game.panStarted, isTrue);
+        expect(game.panEnded, isTrue);
+      },
+    );
+  });
+}

packages/flame/test/game/game_widget/game_widget_tap_test.dart

@@ -0,0 +1,26 @@
+import 'package:flame/game.dart';
+import 'package:flame/input.dart';
+import 'package:flame_test/flame_test.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+class TapGame extends FlameGame with TapDetector {
+  bool tapRegistered = false;
+
+  @override
+  void onTap() {
+    tapRegistered = true;
+  }
+}
+
+void main() {
+  group('GameWidget - TapDetectors', () {
+    flameWidgetTest<TapGame>(
+      'can receive taps',
+      createGame: () => TapGame(),
+      verify: (game, tester) async {
+        await tester.tapAt(const Offset(10, 10));
+        expect(game.tapRegistered, isTrue);
+      },
+    );
+  });
+}

packages/flame_test/CHANGELOG.md

@@ -1,5 +1,8 @@
 # CHANGELOG
 
+## [next]
+ - Add `flameTest` and `flameWidgetTest`
+
 ## [0.1.1-releasecandidate.13]
  - Move dartdoc and dart_code_metrics to dev_dependencies
 

packages/flame_test/example/lib/game.dart

@@ -0,0 +1,18 @@
+import 'package:flame/components.dart';
+import 'package:flame/game.dart';
+import 'package:flutter/material.dart';
+
+class MyGameWidget extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    return GameWidget(game: MyGame());
+  }
+}
+
+class MyGame extends FlameGame {
+  @override
+  Future<void> onLoad() async {
+    final citySprite = await loadSprite('city.png');
+    await add(SpriteComponent(sprite: citySprite, size: Vector2.all(200)));
+  }
+}

packages/flame_test/example/pubspec.yaml

@@ -21,3 +21,7 @@ dev_dependencies:
     path: ../
   test: ^1.17.10
   dart_code_metrics: ^4.1.0
+
+flutter:
+  assets:
+    - assets/images/

packages/flame_test/example/test/flame_test_test.dart

@@ -0,0 +1,28 @@
+import 'package:example/game.dart';
+import 'package:flame_test/flame_test.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('flameTest', () {
+    TestWidgetsFlutterBinding.ensureInitialized();
+
+    flameTest<MyGame>(
+      'can load the game',
+      createGame: () => MyGame(),
+      verify: (game) {
+        expect(game.children.length, 1);
+      },
+    );
+
+    flameWidgetTest(
+      'render the game widget',
+      createGame: () => MyGame(),
+      verify: (game, tester) async {
+        expect(
+          find.byGame<MyGame>(),
+          findsOneWidget,
+        );
+      },
+    );
+  });
+}

packages/flame_test/lib/flame_test.dart

@@ -1,5 +1,6 @@
 export 'src/expect_double.dart';
 export 'src/expect_vector2.dart';
+export 'src/flame_test.dart';
 export 'src/mock_gesture_events.dart';
 export 'src/mock_image.dart';
 export 'src/random_test.dart';

packages/flame_test/lib/src/flame_test.dart

@@ -0,0 +1,81 @@
+import 'package:flame/game.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:meta/meta.dart';
+
+extension FlameFinds on CommonFinders {
+  Finder byGame<T extends Game>() {
+    return find.byWidgetPredicate(
+      (widget) => widget is GameWidget<T>,
+    );
+  }
+}
+
+typedef GameCreateFunction<T extends Game> = T Function();
+typedef VerifyFunction<T extends Game> = void Function(T);
+
+/// Creates a [Game] specific test case with given [description].
+///
+/// Use [createGame] to create your game instance.
+///
+/// Use [verify] closure to make verifications/assertions.
+@isTest
+void flameTest<T extends Game>(
+  String description, {
+  required GameCreateFunction<T> createGame,
+  VerifyFunction<T>? verify,
+  Vector2? gameSize,
+}) {
+  test(description, () async {
+    final game = createGame();
+
+    final size = gameSize ?? Vector2.all(500);
+    game.onGameResize(size);
+
+    await game.onLoad();
+    game.update(0);
+
+    if (verify != null) {
+      verify(game);
+    }
+  });
+}
+
+typedef GameWidgetCreateFunction<T extends Game> = GameWidget<T> Function(
+    T game);
+typedef WidgetVerifyFunction<T extends Game> = Future<void> Function(
+  T,
+  WidgetTester,
+);
+
+/// Creates a [Game] specific test case with given [description]
+/// which runs inside the Flutter test environment.
+///
+/// Use [createGame] to create your game instance.
+///
+/// Use [createGameWidget] to create the [GameWidget], if omitted
+/// the game instance returned by [createGame] will be wrapped into
+/// an empty [GameWidget] instance.
+///
+/// Use [verify] closure to make verifications/assertions.
+@isTest
+void flameWidgetTest<T extends Game>(
+  String description, {
+  required GameCreateFunction<T> createGame,
+  GameWidgetCreateFunction<T>? createGameWidget,
+  WidgetVerifyFunction<T>? verify,
+}) {
+  testWidgets(description, (tester) async {
+    final game = createGame();
+
+    await tester.runAsync(() async {
+      final gameWidget = createGameWidget?.call(game) ?? GameWidget(game: game);
+
+      await tester.pumpWidget(gameWidget);
+      await tester.pump();
+
+      if (verify != null) {
+        await verify(game, tester);
+      }
+    });
+  });
+}