Renamed variables to be consistent

2025-11-21 13:47:27 +01:00
parent d948f2f13d
commit 8c05385203
5 changed files with 183 additions and 180 deletions
--- a/test/db_tests/game_test.dart
+++ b/test/db_tests/game_test.dart
@@ -9,17 +9,17 @@ import 'package:game_tracker/data/dto/player.dart';

 void main() {
  late AppDatabase database;
-  late Player player1;
-  late Player player2;
-  late Player player3;
-  late Player player4;
-  late Player player5;
-  late Group testgroup;
-  late Group testgroup2;
-  late Game testgame1;
-  late Game testgame2;
-  late Game testgameWithPlayer;
-  late Game testgameWithGroup;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
+  late Player testPlayer5;
+  late Group testGroup1;
+  late Group testGroup2;
+  late Game testGame1;
+  late Game testGame2;
+  late Game testGameOnlyPlayers;
+  late Game testGameOnlyGroup;
  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
  final fakeClock = Clock(() => fixedDate);

@@ -33,31 +33,34 @@ void main() {
    );

    withClock(fakeClock, () {
-      player1 = Player(name: 'Alice');
-      player2 = Player(name: 'Bob');
-      player3 = Player(name: 'Charlie');
-      player4 = Player(name: 'Diana');
-      player5 = Player(name: 'Eve');
-      testgroup = Group(
+      testPlayer1 = Player(name: 'Alice');
+      testPlayer2 = Player(name: 'Bob');
+      testPlayer3 = Player(name: 'Charlie');
+      testPlayer4 = Player(name: 'Diana');
+      testPlayer5 = Player(name: 'Eve');
+      testGroup1 = Group(
        name: 'Test Group 2',
-        members: [player1, player2, player3],
+        members: [testPlayer1, testPlayer2, testPlayer3],
      );
-      testgroup2 = Group(name: 'Test Group 2', members: [player4, player5]);
-      testgame1 = Game(
-        name: 'Test Game',
-        group: testgroup,
-        players: [player4, player5],
+      testGroup2 = Group(
+        name: 'Test Group 2',
+        members: [testPlayer4, testPlayer5],
      );
-      testgame2 = Game(
+      testGame1 = Game(
+        name: 'First Test Game',
+        group: testGroup1,
+        players: [testPlayer4, testPlayer5],
+      );
+      testGame2 = Game(
        name: 'Second Test Game',
-        group: testgroup2,
-        players: [player1, player2, player3],
+        group: testGroup2,
+        players: [testPlayer1, testPlayer2, testPlayer3],
      );
-      testgameWithPlayer = Game(
-        name: 'Second Test Game',
-        players: [player1, player2, player3],
+      testGameOnlyPlayers = Game(
+        name: 'Test Game with Players',
+        players: [testPlayer1, testPlayer2, testPlayer3],
      );
-      testgameWithGroup = Game(name: 'Second Test Game', group: testgroup2);
+      testGameOnlyGroup = Game(name: 'Test Game with Group', group: testGroup2);
    });
  });
  tearDown(() async {
@@ -66,32 +69,32 @@ void main() {

  group('Game Tests', () {
    test('Adding and fetching single game works correclty', () async {
-      await database.gameDao.addGame(game: testgame1);
+      await database.gameDao.addGame(game: testGame1);

-      final result = await database.gameDao.getGameById(gameId: testgame1.id);
+      final result = await database.gameDao.getGameById(gameId: testGame1.id);

-      expect(result.id, testgame1.id);
-      expect(result.name, testgame1.name);
-      expect(result.winner, testgame1.winner);
-      expect(result.createdAt, testgame1.createdAt);
+      expect(result.id, testGame1.id);
+      expect(result.name, testGame1.name);
+      expect(result.winner, testGame1.winner);
+      expect(result.createdAt, testGame1.createdAt);

      if (result.group != null) {
-        expect(result.group!.members.length, testgroup.members.length);
+        expect(result.group!.members.length, testGroup1.members.length);

-        for (int i = 0; i < testgroup.members.length; i++) {
-          expect(result.group!.members[i].id, testgroup.members[i].id);
-          expect(result.group!.members[i].name, testgroup.members[i].name);
+        for (int i = 0; i < testGroup1.members.length; i++) {
+          expect(result.group!.members[i].id, testGroup1.members[i].id);
+          expect(result.group!.members[i].name, testGroup1.members[i].name);
        }
      } else {
        fail('Group is null');
      }
      if (result.players != null) {
-        expect(result.players!.length, testgame1.players!.length);
+        expect(result.players!.length, testGame1.players!.length);

-        for (int i = 0; i < testgame1.players!.length; i++) {
-          expect(result.players![i].id, testgame1.players![i].id);
-          expect(result.players![i].name, testgame1.players![i].name);
-          expect(result.players![i].createdAt, testgame1.players![i].createdAt);
+        for (int i = 0; i < testGame1.players!.length; i++) {
+          expect(result.players![i].id, testGame1.players![i].id);
+          expect(result.players![i].name, testGame1.players![i].name);
+          expect(result.players![i].createdAt, testGame1.players![i].createdAt);
        }
      } else {
        fail('Players is null');
@@ -100,19 +103,19 @@ void main() {

    test('Adding and fetching multiple games works correctly', () async {
      // TODO: Use upcoming addGames() method
-      await database.gameDao.addGame(game: testgame1);
-      await database.gameDao.addGame(game: testgame2);
-      await database.gameDao.addGame(game: testgameWithGroup);
-      await database.gameDao.addGame(game: testgameWithPlayer);
+      await database.gameDao.addGame(game: testGame1);
+      await database.gameDao.addGame(game: testGame2);
+      await database.gameDao.addGame(game: testGameOnlyGroup);
+      await database.gameDao.addGame(game: testGameOnlyPlayers);

      final allGames = await database.gameDao.getAllGames();
      expect(allGames.length, 4);

      final testGames = {
-        testgame1.id: testgame1,
-        testgame2.id: testgame2,
-        testgameWithGroup.id: testgameWithGroup,
-        testgameWithPlayer.id: testgameWithPlayer,
+        testGame1.id: testGame1,
+        testGame2.id: testGame2,
+        testGameOnlyGroup.id: testGameOnlyGroup,
+        testGameOnlyPlayers.id: testGameOnlyPlayers,
      };

      for (final game in allGames) {
@@ -167,33 +170,33 @@ void main() {
    });

    test('Adding the same game twice does not create duplicates', () async {
-      await database.gameDao.addGame(game: testgame1);
-      await database.gameDao.addGame(game: testgame1);
+      await database.gameDao.addGame(game: testGame1);
+      await database.gameDao.addGame(game: testGame1);

      final gameCount = await database.gameDao.getGameCount();
      expect(gameCount, 1);
    });

    test('Game existence check works correctly', () async {
-      var gameExists = await database.gameDao.gameExists(gameId: testgame1.id);
+      var gameExists = await database.gameDao.gameExists(gameId: testGame1.id);
      expect(gameExists, false);

-      await database.gameDao.addGame(game: testgame1);
+      await database.gameDao.addGame(game: testGame1);

-      gameExists = await database.gameDao.gameExists(gameId: testgame1.id);
+      gameExists = await database.gameDao.gameExists(gameId: testGame1.id);
      expect(gameExists, true);
    });

    test('Deleting a game works correclty', () async {
-      await database.gameDao.addGame(game: testgame1);
+      await database.gameDao.addGame(game: testGame1);

      final gameDeleted = await database.gameDao.deleteGame(
-        gameId: testgame1.id,
+        gameId: testGame1.id,
      );
      expect(gameDeleted, true);

      final gameExists = await database.gameDao.gameExists(
-        gameId: testgame1.id,
+        gameId: testGame1.id,
      );
      expect(gameExists, false);
    });
@@ -202,22 +205,22 @@ void main() {
      var gameCount = await database.gameDao.getGameCount();
      expect(gameCount, 0);

-      await database.gameDao.addGame(game: testgame1);
+      await database.gameDao.addGame(game: testGame1);

      gameCount = await database.gameDao.getGameCount();
      expect(gameCount, 1);

-      await database.gameDao.addGame(game: testgame2);
+      await database.gameDao.addGame(game: testGame2);

      gameCount = await database.gameDao.getGameCount();
      expect(gameCount, 2);

-      await database.gameDao.deleteGame(gameId: testgame1.id);
+      await database.gameDao.deleteGame(gameId: testGame1.id);

      gameCount = await database.gameDao.getGameCount();
      expect(gameCount, 1);

-      await database.gameDao.deleteGame(gameId: testgame2.id);
+      await database.gameDao.deleteGame(gameId: testGame2.id);

      gameCount = await database.gameDao.getGameCount();
      expect(gameCount, 0);
--- a/test/db_tests/group_game_test.dart
+++ b/test/db_tests/group_game_test.dart
@@ -9,11 +9,11 @@ import 'package:game_tracker/data/dto/player.dart';

 void main() {
  late AppDatabase database;
-  late Player player1;
-  late Player player2;
-  late Player player3;
-  late Player player4;
-  late Player player5;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
+  late Player testPlayer5;
  late Group testgroup;
  late Game testgameWithGroup;
  late Game testgameWithPlayers;
@@ -30,20 +30,20 @@ void main() {
    );

    withClock(fakeClock, () {
-      player1 = Player(name: 'Alice');
-      player2 = Player(name: 'Bob');
-      player3 = Player(name: 'Charlie');
-      player4 = Player(name: 'Diana');
-      player5 = Player(name: 'Eve');
+      testPlayer1 = Player(name: 'Alice');
+      testPlayer2 = Player(name: 'Bob');
+      testPlayer3 = Player(name: 'Charlie');
+      testPlayer4 = Player(name: 'Diana');
+      testPlayer5 = Player(name: 'Eve');
      testgroup = Group(
        name: 'Test Group',
-        members: [player1, player2, player3],
+        members: [testPlayer1, testPlayer2, testPlayer3],
      );
      testgameWithPlayers = Game(
-        name: 'Game with Players',
-        players: [player4, player5],
+        name: 'Test Game with Players',
+        players: [testPlayer4, testPlayer5],
      );
-      testgameWithGroup = Game(name: 'Game with Group', group: testgroup);
+      testgameWithGroup = Game(name: 'Test Game with Group', group: testgroup);
    });
  });
  tearDown(() async {
--- a/test/db_tests/group_test.dart
+++ b/test/db_tests/group_test.dart
@@ -8,14 +8,14 @@ import 'package:game_tracker/data/dto/player.dart';

 void main() {
  late AppDatabase database;
-  late Player player1;
-  late Player player2;
-  late Player player3;
-  late Player player4;
-  late Group testgroup;
-  late Group testgroup2;
-  late Group testgroup3;
-  late Group testgroup4;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
+  late Group testGroup1;
+  late Group testGroup2;
+  late Group testGroup3;
+  late Group testGroup4;
  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
  final fakeClock = Clock(() => fixedDate);

@@ -29,28 +29,28 @@ void main() {
    );

    withClock(fakeClock, () {
-      player1 = Player(name: 'Alice');
-      player2 = Player(name: 'Bob');
-      player3 = Player(name: 'Charlie');
-      player4 = Player(name: 'Diana');
-      testgroup = Group(
+      testPlayer1 = Player(name: 'Alice');
+      testPlayer2 = Player(name: 'Bob');
+      testPlayer3 = Player(name: 'Charlie');
+      testPlayer4 = Player(name: 'Diana');
+      testGroup1 = Group(
        name: 'Test Group',
-        members: [player1, player2, player3],
+        members: [testPlayer1, testPlayer2, testPlayer3],
      );
-      testgroup2 = Group(
+      testGroup2 = Group(
        id: 'gr2',
        name: 'Second Group',
-        members: [player2, player3, player4],
+        members: [testPlayer2, testPlayer3, testPlayer4],
      );
-      testgroup3 = Group(
+      testGroup3 = Group(
        id: 'gr2',
        name: 'Second Group',
-        members: [player2, player4],
+        members: [testPlayer2, testPlayer4],
      );
-      testgroup4 = Group(
+      testGroup4 = Group(
        id: 'gr2',
        name: 'Second Group',
-        members: [player1, player2, player3, player4],
+        members: [testPlayer1, testPlayer2, testPlayer3, testPlayer4],
      );
    });
  });
@@ -59,38 +59,38 @@ void main() {
  });
  group('Group Tests', () {
    test('Adding and fetching a single group works correctly', () async {
-      await database.groupDao.addGroup(group: testgroup);
+      await database.groupDao.addGroup(group: testGroup1);

      final fetchedGroup = await database.groupDao.getGroupById(
-        groupId: testgroup.id,
+        groupId: testGroup1.id,
      );

-      expect(fetchedGroup.id, testgroup.id);
-      expect(fetchedGroup.name, testgroup.name);
-      expect(fetchedGroup.createdAt, testgroup.createdAt);
+      expect(fetchedGroup.id, testGroup1.id);
+      expect(fetchedGroup.name, testGroup1.name);
+      expect(fetchedGroup.createdAt, testGroup1.createdAt);

-      expect(fetchedGroup.members.length, testgroup.members.length);
-      for (int i = 0; i < testgroup.members.length; i++) {
-        expect(fetchedGroup.members[i].id, testgroup.members[i].id);
-        expect(fetchedGroup.members[i].name, testgroup.members[i].name);
+      expect(fetchedGroup.members.length, testGroup1.members.length);
+      for (int i = 0; i < testGroup1.members.length; i++) {
+        expect(fetchedGroup.members[i].id, testGroup1.members[i].id);
+        expect(fetchedGroup.members[i].name, testGroup1.members[i].name);
        expect(
          fetchedGroup.members[i].createdAt,
-          testgroup.members[i].createdAt,
+          testGroup1.members[i].createdAt,
        );
      }
    });

    test('Adding and fetching multiple groups works correctly', () async {
      // TODO: Use upcoming addGroups() method
-      await database.groupDao.addGroup(group: testgroup);
-      await database.groupDao.addGroup(group: testgroup2);
-      await database.groupDao.addGroup(group: testgroup3);
-      await database.groupDao.addGroup(group: testgroup4);
+      await database.groupDao.addGroup(group: testGroup1);
+      await database.groupDao.addGroup(group: testGroup2);
+      await database.groupDao.addGroup(group: testGroup3);
+      await database.groupDao.addGroup(group: testGroup4);

      final allGroups = await database.groupDao.getAllGroups();
      expect(allGroups.length, 2);

-      final testGroups = {testgroup.id: testgroup, testgroup2.id: testgroup2};
+      final testGroups = {testGroup1.id: testGroup1, testGroup2.id: testGroup2};

      for (final group in allGroups) {
        final expectedGroup = testGroups[group.id]!;
@@ -112,8 +112,8 @@ void main() {
    });

    test('Adding the same group twice does not create duplicates', () async {
-      await database.groupDao.addGroup(group: testgroup);
-      await database.groupDao.addGroup(group: testgroup);
+      await database.groupDao.addGroup(group: testGroup1);
+      await database.groupDao.addGroup(group: testGroup1);

      final allGroups = await database.groupDao.getAllGroups();
      expect(allGroups.length, 1);
@@ -121,42 +121,42 @@ void main() {

    test('Group existence check works correctly', () async {
      var groupExists = await database.groupDao.groupExists(
-        groupId: testgroup.id,
+        groupId: testGroup1.id,
      );
      expect(groupExists, false);

-      await database.groupDao.addGroup(group: testgroup);
+      await database.groupDao.addGroup(group: testGroup1);

-      groupExists = await database.groupDao.groupExists(groupId: testgroup.id);
+      groupExists = await database.groupDao.groupExists(groupId: testGroup1.id);
      expect(groupExists, true);
    });

    test('Deleting a group works correclty', () async {
-      await database.groupDao.addGroup(group: testgroup);
+      await database.groupDao.addGroup(group: testGroup1);

      final groupDeleted = await database.groupDao.deleteGroup(
-        groupId: testgroup.id,
+        groupId: testGroup1.id,
      );
      expect(groupDeleted, true);

      final groupExists = await database.groupDao.groupExists(
-        groupId: testgroup.id,
+        groupId: testGroup1.id,
      );
      expect(groupExists, false);
    });

    test('Updating a group name works correcly', () async {
-      await database.groupDao.addGroup(group: testgroup);
+      await database.groupDao.addGroup(group: testGroup1);

      const newGroupName = 'new group name';

      await database.groupDao.updateGroupname(
-        groupId: testgroup.id,
+        groupId: testGroup1.id,
        newName: newGroupName,
      );

      final result = await database.groupDao.getGroupById(
-        groupId: testgroup.id,
+        groupId: testGroup1.id,
      );
      expect(result.name, newGroupName);
    });
@@ -165,13 +165,13 @@ void main() {
      final initialCount = await database.groupDao.getGroupCount();
      expect(initialCount, 0);

-      await database.groupDao.addGroup(group: testgroup);
+      await database.groupDao.addGroup(group: testGroup1);

      final groupAdded = await database.groupDao.getGroupCount();
      expect(groupAdded, 1);

      final groupRemoved = await database.groupDao.deleteGroup(
-        groupId: testgroup.id,
+        groupId: testGroup1.id,
      );
      expect(groupRemoved, true);

--- a/test/db_tests/player_game_test.dart
+++ b/test/db_tests/player_game_test.dart
@@ -9,15 +9,15 @@ import 'package:game_tracker/data/dto/player.dart';

 void main() {
  late AppDatabase database;
-  late Player player1;
-  late Player player2;
-  late Player player3;
-  late Player player4;
-  late Player player5;
-  late Player player6;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
+  late Player testPlayer5;
+  late Player testPlayer6;
  late Group testgroup;
-  late Game testgameWithGroup;
-  late Game testgameWithPlayers;
+  late Game testGameOnlyGroup;
+  late Game testGameOnlyPlayers;
  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
  final fakeClock = Clock(() => fixedDate);

@@ -31,20 +31,20 @@ void main() {
    );

    withClock(fakeClock, () {
-      player1 = Player(name: 'Alice');
-      player2 = Player(name: 'Bob');
-      player3 = Player(name: 'Charlie');
-      player4 = Player(name: 'Diana');
-      player5 = Player(name: 'Eve');
-      player6 = Player(name: 'Frank');
+      testPlayer1 = Player(name: 'Alice');
+      testPlayer2 = Player(name: 'Bob');
+      testPlayer3 = Player(name: 'Charlie');
+      testPlayer4 = Player(name: 'Diana');
+      testPlayer5 = Player(name: 'Eve');
+      testPlayer6 = Player(name: 'Frank');
      testgroup = Group(
        name: 'Test Group',
-        members: [player1, player2, player3],
+        members: [testPlayer1, testPlayer2, testPlayer3],
      );
-      testgameWithGroup = Game(name: 'Test Game', group: testgroup);
-      testgameWithPlayers = Game(
+      testGameOnlyGroup = Game(name: 'Test Game with Group', group: testgroup);
+      testGameOnlyPlayers = Game(
        name: 'Test Game with Players',
-        players: [player4, player5, player6],
+        players: [testPlayer4, testPlayer5, testPlayer6],
      );
    });
  });
@@ -54,44 +54,44 @@ void main() {

  group('Player-Game Tests', () {
    test('Game has player works correctly', () async {
-      database.gameDao.addGame(game: testgameWithGroup);
-      database.playerDao.addPlayer(player: player1);
+      database.gameDao.addGame(game: testGameOnlyGroup);
+      database.playerDao.addPlayer(player: testPlayer1);

      var gameHasPlayers = await database.playerGameDao.gameHasPlayers(
-        gameId: testgameWithGroup.id,
+        gameId: testGameOnlyGroup.id,
      );

      expect(gameHasPlayers, false);

      database.playerGameDao.addPlayerToGame(
-        gameId: testgameWithGroup.id,
-        playerId: player1.id,
+        gameId: testGameOnlyGroup.id,
+        playerId: testPlayer1.id,
      );

      gameHasPlayers = await database.playerGameDao.gameHasPlayers(
-        gameId: testgameWithGroup.id,
+        gameId: testGameOnlyGroup.id,
      );

      expect(gameHasPlayers, true);
    });

    test('Adding a player to a game works correctly', () async {
-      database.gameDao.addGame(game: testgameWithGroup);
-      database.playerDao.addPlayer(player: player5);
+      database.gameDao.addGame(game: testGameOnlyGroup);
+      database.playerDao.addPlayer(player: testPlayer5);
      database.playerGameDao.addPlayerToGame(
-        gameId: testgameWithGroup.id,
-        playerId: player5.id,
+        gameId: testGameOnlyGroup.id,
+        playerId: testPlayer5.id,
      );

      var playerAdded = await database.playerGameDao.isPlayerInGame(
-        gameId: testgameWithGroup.id,
-        playerId: player5.id,
+        gameId: testGameOnlyGroup.id,
+        playerId: testPlayer5.id,
      );

      expect(playerAdded, true);

      playerAdded = await database.playerGameDao.isPlayerInGame(
-        gameId: testgameWithGroup.id,
+        gameId: testGameOnlyGroup.id,
        playerId: '',
      );

@@ -99,20 +99,20 @@ void main() {
    });

    test('Removing player from game works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithPlayers);
+      await database.gameDao.addGame(game: testGameOnlyPlayers);

-      final playerToRemove = testgameWithPlayers.players![0];
+      final playerToRemove = testGameOnlyPlayers.players![0];

      final removed = await database.playerGameDao.removePlayerFromGame(
        playerId: playerToRemove.id,
-        gameId: testgameWithPlayers.id,
+        gameId: testGameOnlyPlayers.id,
      );
      expect(removed, true);

      final result = await database.gameDao.getGameById(
-        gameId: testgameWithPlayers.id,
+        gameId: testGameOnlyPlayers.id,
      );
-      expect(result.players!.length, testgameWithPlayers.players!.length - 1);
+      expect(result.players!.length, testGameOnlyPlayers.players!.length - 1);

      final playerExists = result.players!.any(
        (p) => p.id == playerToRemove.id,
@@ -121,9 +121,9 @@ void main() {
    });

    test('Retrieving players of a game works correctly', () async {
-      await database.gameDao.addGame(game: testgameWithPlayers);
+      await database.gameDao.addGame(game: testGameOnlyPlayers);
      final players = await database.playerGameDao.getPlayersOfGame(
-        gameId: testgameWithPlayers.id,
+        gameId: testGameOnlyPlayers.id,
      );

      if (players == null) {
@@ -131,9 +131,9 @@ void main() {
      }

      for (int i = 0; i < players.length; i++) {
-        expect(players[i].id, testgameWithPlayers.players![i].id);
-        expect(players[i].name, testgameWithPlayers.players![i].name);
-        expect(players[i].createdAt, testgameWithPlayers.players![i].createdAt);
+        expect(players[i].id, testGameOnlyPlayers.players![i].id);
+        expect(players[i].name, testGameOnlyPlayers.players![i].name);
+        expect(players[i].createdAt, testGameOnlyPlayers.players![i].createdAt);
      }
    });
  });
--- a/test/db_tests/player_group_test.dart
+++ b/test/db_tests/player_group_test.dart
@@ -8,10 +8,10 @@ import 'package:game_tracker/data/dto/player.dart';

 void main() {
  late AppDatabase database;
-  late Player player1;
-  late Player player2;
-  late Player player3;
-  late Player player4;
+  late Player testPlayer1;
+  late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
  late Group testgroup;
  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
  final fakeClock = Clock(() => fixedDate);
@@ -26,13 +26,13 @@ void main() {
    );

    withClock(fakeClock, () {
-      player1 = Player(name: 'Alice');
-      player2 = Player(name: 'Bob');
-      player3 = Player(name: 'Charlie');
-      player4 = Player(name: 'Diana');
+      testPlayer1 = Player(name: 'Alice');
+      testPlayer2 = Player(name: 'Bob');
+      testPlayer3 = Player(name: 'Charlie');
+      testPlayer4 = Player(name: 'Diana');
      testgroup = Group(
        name: 'Test Group',
-        members: [player1, player2, player3],
+        members: [testPlayer1, testPlayer2, testPlayer3],
      );
    });
  });
@@ -46,15 +46,15 @@ void main() {

    test('Adding a player to a group works correctly', () async {
      await database.groupDao.addGroup(group: testgroup);
-      await database.playerDao.addPlayer(player: player4);
+      await database.playerDao.addPlayer(player: testPlayer4);
      await database.playerGroupDao.addPlayerToGroup(
        groupId: testgroup.id,
-        player: player4,
+        player: testPlayer4,
      );

      var playerAdded = await database.playerGroupDao.isPlayerInGroup(
        groupId: testgroup.id,
-        playerId: player4.id,
+        playerId: testPlayer4.id,
      );

      expect(playerAdded, true);