pinball/test/game/components/controlled_flipper_test.dart

import 'dart:collection';

import 'package:bloc_test/bloc_test.dart';
import 'package:flame_test/flame_test.dart';
import 'package:flutter/services.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:mocktail/mocktail.dart';
import 'package:pinball/game/game.dart';
import 'package:pinball_components/pinball_components.dart';

import '../../helpers/helpers.dart';

class _MockGameBloc extends Mock implements GameBloc {}

void main() {
  TestWidgetsFlutterBinding.ensureInitialized();
  final assets = [
    Assets.images.flipper.left.keyName,
    Assets.images.flipper.right.keyName,
  ];
  final flameTester = FlameTester(
    () => EmptyPinballTestGame(assets: assets),
  );

  group('FlipperController', () {
    late GameBloc gameBloc;

    setUp(() {
      gameBloc = _MockGameBloc();
    });

    final flameBlocTester = FlameBlocTester<EmptyPinballTestGame, GameBloc>(
      gameBuilder: EmptyPinballTestGame.new,
      blocBuilder: () => gameBloc,
      assets: assets,
    );

    group('onKeyEvent', () {
      final leftKeys = UnmodifiableListView([
        LogicalKeyboardKey.arrowLeft,
        LogicalKeyboardKey.keyA,
      ]);
      final rightKeys = UnmodifiableListView([
        LogicalKeyboardKey.arrowRight,
        LogicalKeyboardKey.keyD,
      ]);

      group('and Flipper is left', () {
        late Flipper flipper;
        late FlipperController controller;

        setUp(() {
          flipper = Flipper(side: BoardSide.left);
          controller = FlipperController(flipper);
          flipper.add(controller);
        });

        testRawKeyDownEvents(leftKeys, (event) {
          flameTester.test(
            'moves upwards '
            'when ${event.logicalKey.keyLabel} is pressed',
            (game) async {
              whenListen(
                gameBloc,
                const Stream<GameState>.empty(),
                initialState: const GameState.initial(),
              );

              await game.ready();
              await game.add(flipper);
              controller.onKeyEvent(event, {});

              expect(flipper.body.linearVelocity.y, isNegative);
              expect(flipper.body.linearVelocity.x, isZero);
            },
          );
        });

        testRawKeyDownEvents(leftKeys, (event) {
          flameBlocTester.testGameWidget(
            'does nothing when is game over',
            setUp: (game, tester) async {
              whenListen(
                gameBloc,
                const Stream<GameState>.empty(),
                initialState: const GameState.initial().copyWith(
                  status: GameStatus.gameOver,
                ),
              );

              await game.ensureAdd(flipper);
              controller.onKeyEvent(event, {});
            },
            verify: (game, tester) async {
              expect(flipper.body.linearVelocity.y, isZero);
              expect(flipper.body.linearVelocity.x, isZero);
            },
          );
        });

        testRawKeyUpEvents(leftKeys, (event) {
          flameTester.test(
            'moves downwards '
            'when ${event.logicalKey.keyLabel} is released',
            (game) async {
              whenListen(
                gameBloc,
                const Stream<GameState>.empty(),
                initialState: const GameState.initial(),
              );

              await game.ready();
              await game.add(flipper);
              controller.onKeyEvent(event, {});

              expect(flipper.body.linearVelocity.y, isPositive);
              expect(flipper.body.linearVelocity.x, isZero);
            },
          );
        });

        testRawKeyUpEvents(rightKeys, (event) {
          flameTester.test(
            'does nothing '
            'when ${event.logicalKey.keyLabel} is released',
            (game) async {
              whenListen(
                gameBloc,
                const Stream<GameState>.empty(),
                initialState: const GameState.initial(),
              );

              await game.ready();
              await game.add(flipper);
              controller.onKeyEvent(event, {});

              expect(flipper.body.linearVelocity.y, isZero);
              expect(flipper.body.linearVelocity.x, isZero);
            },
          );
        });
      });

      group('and Flipper is right', () {
        late Flipper flipper;
        late FlipperController controller;

        setUp(() {
          flipper = Flipper(side: BoardSide.right);
          controller = FlipperController(flipper);
          flipper.add(controller);
        });

        testRawKeyDownEvents(rightKeys, (event) {
          flameTester.test(
            'moves upwards '
            'when ${event.logicalKey.keyLabel} is pressed',
            (game) async {
              whenListen(
                gameBloc,
                const Stream<GameState>.empty(),
                initialState: const GameState.initial(),
              );

              await game.ready();
              await game.add(flipper);
              controller.onKeyEvent(event, {});

              expect(flipper.body.linearVelocity.y, isNegative);
              expect(flipper.body.linearVelocity.x, isZero);
            },
          );
        });

        testRawKeyUpEvents(rightKeys, (event) {
          flameTester.test(
            'moves downwards '
            'when ${event.logicalKey.keyLabel} is released',
            (game) async {
              whenListen(
                gameBloc,
                const Stream<GameState>.empty(),
                initialState: const GameState.initial(),
              );

              await game.ready();
              await game.add(flipper);
              controller.onKeyEvent(event, {});

              expect(flipper.body.linearVelocity.y, isPositive);
              expect(flipper.body.linearVelocity.x, isZero);
            },
          );
        });

        testRawKeyDownEvents(rightKeys, (event) {
          flameBlocTester.testGameWidget(
            'does nothing when is game over',
            setUp: (game, tester) async {
              whenListen(
                gameBloc,
                const Stream<GameState>.empty(),
                initialState: const GameState.initial().copyWith(
                  status: GameStatus.gameOver,
                ),
              );

              await game.ensureAdd(flipper);
              controller.onKeyEvent(event, {});
            },
            verify: (game, tester) async {
              expect(flipper.body.linearVelocity.y, isZero);
              expect(flipper.body.linearVelocity.x, isZero);
            },
          );
        });

        testRawKeyUpEvents(leftKeys, (event) {
          flameTester.test(
            'does nothing '
            'when ${event.logicalKey.keyLabel} is released',
            (game) async {
              await game.ready();
              await game.add(flipper);
              controller.onKeyEvent(event, {});

              expect(flipper.body.linearVelocity.y, isZero);
              expect(flipper.body.linearVelocity.x, isZero);
            },
          );
        });
      });
    });
  });
}