Refactored tests in own files

test/db_tests/game_test.dart

@@ -14,12 +14,12 @@ void main() {
   late Player player3;
   late Player player4;
   late Player player5;
-  late Player player6;
   late Group testgroup;
   late Group testgroup2;
-  late Game testgame;
+  late Game testgame1;
   late Game testgame2;
-  late Game testgame3;
+  late Game testgameWithPlayer;
+  late Game testgameWithGroup;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
@@ -38,16 +38,12 @@ void main() {
       player3 = Player(name: 'Charlie');
       player4 = Player(name: 'Diana');
       player5 = Player(name: 'Eve');
-      player6 = Player(name: 'Frank');
       testgroup = Group(
-        name: 'Test Group',
+        name: 'Test Group 2',
         members: [player1, player2, player3],
       );
-      testgroup2 = Group(
-        name: 'Test Group',
-        members: [player1, player2, player3],
-      );
-      testgame = Game(
+      testgroup2 = Group(name: 'Test Group 2', members: [player4, player5]);
+      testgame1 = Game(
         name: 'Test Game',
         group: testgroup,
         players: [player4, player5],
@@ -57,7 +53,11 @@ void main() {
         group: testgroup2,
         players: [player1, player2, player3],
       );
-      testgame3 = Game(name: 'Third Test Game', players: [player4, player5]);
+      testgameWithPlayer = Game(
+        name: 'Second Test Game',
+        players: [player1, player2, player3],
+      );
+      testgameWithGroup = Game(name: 'Second Test Game', group: testgroup2);
     });
   });
   tearDown(() async {
@@ -66,14 +66,14 @@ void main() {
 
   group('Game Tests', () {
     test('Adding and fetching single game works correclty', () async {
-      await database.gameDao.addGame(game: testgame);
+      await database.gameDao.addGame(game: testgame1);
 
-      final result = await database.gameDao.getGameById(gameId: testgame.id);
+      final result = await database.gameDao.getGameById(gameId: testgame1.id);
 
-      expect(result.id, testgame.id);
-      expect(result.name, testgame.name);
-      expect(result.winner, testgame.winner);
-      expect(result.createdAt, testgame.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);
@@ -86,12 +86,12 @@ void main() {
         fail('Group is null');
       }
       if (result.players != null) {
-        expect(result.players!.length, testgame.players!.length);
+        expect(result.players!.length, testgame1.players!.length);
 
-        for (int i = 0; i < testgame.players!.length; i++) {
-          expect(result.players![i].id, testgame.players![i].id);
-          expect(result.players![i].name, testgame.players![i].name);
-          expect(result.players![i].createdAt, testgame.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');
@@ -99,51 +99,54 @@ void main() {
     });
 
     // TODO: Use upcoming addGames() method
+    // TODO: Iterate through games
     test('Adding and fetching multiple games works correclty', () async {
-      await database.gameDao.addGame(game: testgame);
+      await database.gameDao.addGame(game: testgame1);
       await database.gameDao.addGame(game: testgame2);
+      await database.gameDao.addGame(game: testgameWithGroup);
+      await database.gameDao.addGame(game: testgameWithPlayer);
 
       final allGames = await database.gameDao.getAllGames();
-      expect(allGames.length, 2);
+      expect(allGames.length, 4);
 
-      final fetchedGame1 = allGames.firstWhere((g) => g.id == testgame.id);
+      final fetchedGame1 = allGames.firstWhere((g) => g.id == testgame1.id);
       // game checks
-      expect(fetchedGame1.id, testgame.id);
-      expect(fetchedGame1.name, testgame.name);
-      expect(fetchedGame1.createdAt, testgame.createdAt);
-      expect(fetchedGame1.winner, testgame.winner);
+      expect(fetchedGame1.id, testgame1.id);
+      expect(fetchedGame1.name, testgame1.name);
+      expect(fetchedGame1.createdAt, testgame1.createdAt);
+      expect(fetchedGame1.winner, testgame1.winner);
 
       // group checks
-      expect(fetchedGame1.group!.id, testgame.group!.id);
-      expect(fetchedGame1.group!.name, testgame.group!.name);
-      expect(fetchedGame1.group!.createdAt, testgame.group!.createdAt);
+      expect(fetchedGame1.group!.id, testgame1.group!.id);
+      expect(fetchedGame1.group!.name, testgame1.group!.name);
+      expect(fetchedGame1.group!.createdAt, testgame1.group!.createdAt);
       // group members checks
       expect(
         fetchedGame1.group!.members.length,
-        testgame.group!.members.length,
+        testgame1.group!.members.length,
       );
-      for (int i = 0; i < testgame.group!.members.length; i++) {
+      for (int i = 0; i < testgame1.group!.members.length; i++) {
         expect(
           fetchedGame1.group!.members[i].id,
-          testgame.group!.members[i].id,
+          testgame1.group!.members[i].id,
         );
         expect(
           fetchedGame1.group!.members[i].name,
-          testgame.group!.members[i].name,
+          testgame1.group!.members[i].name,
         );
         expect(
           fetchedGame1.group!.members[i].createdAt,
-          testgame.group!.members[i].createdAt,
+          testgame1.group!.members[i].createdAt,
         );
       }
 
       // players checks
       for (int i = 0; i < fetchedGame1.players!.length; i++) {
-        expect(fetchedGame1.players![i].id, testgame.players![i].id);
-        expect(fetchedGame1.players![i].name, testgame.players![i].name);
+        expect(fetchedGame1.players![i].id, testgame1.players![i].id);
+        expect(fetchedGame1.players![i].name, testgame1.players![i].name);
         expect(
           fetchedGame1.players![i].createdAt,
-          testgame.players![i].createdAt,
+          testgame1.players![i].createdAt,
         );
       }
 
@@ -190,32 +193,34 @@ void main() {
     });
 
     test('Adding the same game twice does not create duplicates', () async {
-      await database.gameDao.addGame(game: testgame);
-      await database.gameDao.addGame(game: testgame);
+      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: testgame.id);
+      var gameExists = await database.gameDao.gameExists(gameId: testgame1.id);
       expect(gameExists, false);
 
-      await database.gameDao.addGame(game: testgame);
+      await database.gameDao.addGame(game: testgame1);
 
-      gameExists = await database.gameDao.gameExists(gameId: testgame.id);
+      gameExists = await database.gameDao.gameExists(gameId: testgame1.id);
       expect(gameExists, true);
     });
 
     test('Deleting a game works correclty', () async {
-      await database.gameDao.addGame(game: testgame);
+      await database.gameDao.addGame(game: testgame1);
 
       final gameDeleted = await database.gameDao.deleteGame(
-        gameId: testgame.id,
+        gameId: testgame1.id,
       );
       expect(gameDeleted, true);
 
-      final gameExists = await database.gameDao.gameExists(gameId: testgame.id);
+      final gameExists = await database.gameDao.gameExists(
+        gameId: testgame1.id,
+      );
       expect(gameExists, false);
     });
 
@@ -223,7 +228,7 @@ void main() {
       var gameCount = await database.gameDao.getGameCount();
       expect(gameCount, 0);
 
-      await database.gameDao.addGame(game: testgame);
+      await database.gameDao.addGame(game: testgame1);
 
       gameCount = await database.gameDao.getGameCount();
       expect(gameCount, 1);
@@ -233,7 +238,7 @@ void main() {
       gameCount = await database.gameDao.getGameCount();
       expect(gameCount, 2);
 
-      await database.gameDao.deleteGame(gameId: testgame.id);
+      await database.gameDao.deleteGame(gameId: testgame1.id);
 
       gameCount = await database.gameDao.getGameCount();
       expect(gameCount, 1);
@@ -243,58 +248,5 @@ void main() {
       gameCount = await database.gameDao.getGameCount();
       expect(gameCount, 0);
     });
-
-    test(
-      'Adding and removing player to and from a game works correclty',
-      () async {
-        database.gameDao.addGame(game: testgame);
-        database.playerDao.addPlayer(player: player6);
-        database.playerGameDao.addPlayerToGame(
-          gameId: testgame.id,
-          playerId: player6.id,
-        );
-
-        var playerInGame = await database.playerGameDao.isPlayerInGame(
-          gameId: testgame.id,
-          playerId: player6.id,
-        );
-
-        expect(playerInGame, true);
-
-        final playerRemoved = await database.playerGameDao.removePlayerFromGame(
-          gameId: testgame.id,
-          playerId: player6.id,
-        );
-
-        expect(playerRemoved, true);
-
-        playerInGame = await database.playerGameDao.isPlayerInGame(
-          gameId: testgame.id,
-          playerId: player6.id,
-        );
-        expect(playerInGame, false);
-      },
-    );
-
-    test(
-      'Adding and removing a group to and from a game works correclty',
-      () async {
-        database.gameDao.addGame(game: testgame3);
-        database.groupDao.addGroup(group: testgroup);
-        database.groupGameDao.addGroupToGame(testgame3.id, testgroup.id);
-        var gameHasGroup = await database.groupGameDao.gameHasGroup(
-          gameId: testgame3.id,
-        );
-        expect(gameHasGroup, true);
-        final groupRemoved = await database.groupGameDao.removeGroupFromGame(
-          gameId: testgame3.id,
-        );
-        expect(groupRemoved, true);
-        gameHasGroup = await database.groupGameDao.gameHasGroup(
-          gameId: testgame3.id,
-        );
-        expect(gameHasGroup, false);
-      },
-    );
   });
 }

test/db_tests/group_game_test.dart

@@ -0,0 +1,110 @@
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart';
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/dto/game.dart';
+import 'package:game_tracker/data/dto/group.dart';
+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 Game gameWithGroup;
+  late Game gameWithPlayers;
+  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        // Recommended for widget tests to avoid test errors.
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      player1 = Player(name: 'Alice');
+      player2 = Player(name: 'Bob');
+      player3 = Player(name: 'Charlie');
+      player4 = Player(name: 'Diana');
+      player5 = Player(name: 'Eve');
+      testgroup = Group(
+        name: 'Test Group',
+        members: [player1, player2, player3],
+      );
+      gameWithPlayers = Game(
+        name: 'Game with Players',
+        players: [player4, player5],
+      );
+      gameWithGroup = Game(name: 'Game with Group', group: testgroup);
+    });
+  });
+  tearDown(() async {
+    await database.close();
+  });
+  group('Group-Game Tests', () {
+    test('Game has group works correctly', () async {
+      database.gameDao.addGame(game: gameWithPlayers);
+      database.groupDao.addGroup(group: testgroup);
+
+      var gameHasGroup = await database.groupGameDao.gameHasGroup(
+        gameId: gameWithPlayers.id,
+      );
+
+      expect(gameHasGroup, false);
+
+      database.groupGameDao.addGroupToGame(gameWithPlayers.id, testgroup.id);
+
+      gameHasGroup = await database.groupGameDao.gameHasGroup(
+        gameId: gameWithPlayers.id,
+      );
+
+      expect(gameHasGroup, true);
+    });
+
+    test('Adding a group to a game works correctly', () async {
+      database.gameDao.addGame(game: gameWithPlayers);
+      database.groupDao.addGroup(group: testgroup);
+      database.groupGameDao.addGroupToGame(gameWithPlayers.id, testgroup.id);
+
+      var groupAdded = await database.groupGameDao.isGroupInGame(
+        gameId: gameWithPlayers.id,
+        groupId: testgroup.id,
+      );
+      expect(groupAdded, true);
+
+      groupAdded = await database.groupGameDao.isGroupInGame(
+        gameId: gameWithPlayers.id,
+        groupId: '',
+      );
+      expect(groupAdded, false);
+    });
+
+    test('Removing group from game works correctly', () async {
+      await database.gameDao.addGame(game: gameWithGroup);
+
+      final groupToRemove = gameWithGroup.group!;
+
+      final removed = await database.groupGameDao.removeGroupFromGame(
+        groupId: groupToRemove.id,
+        gameId: gameWithGroup.id,
+      );
+      expect(removed, true);
+
+      final result = await database.gameDao.getGameById(
+        gameId: gameWithGroup.id,
+      );
+      expect(result.group, null);
+    });
+
+    // TODO: test getGroupOfGame()
+    test('Retrieving group of a game works correctly', () async {});
+  });
+}

test/db_tests/group_test.dart

@@ -68,7 +68,6 @@ void main() {
       }
     });
 
-    // TODO: Use upcoming addGroups() method
     test('Adding and fetching a single group works correctly', () async {
       await database.groupDao.addGroup(group: testgroup);
       await database.groupDao.addGroup(group: testgroup2);
@@ -89,6 +88,8 @@ void main() {
       expect(fetchedGroup2.members.elementAt(0).createdAt, player2.createdAt);
     });
 
+    // TODO: Use upcoming addGroups() method
+    // TODO: An Test in Game Tests orientieren
     test('Adding the same group twice does not create duplicates', () async {
       await database.groupDao.addGroup(group: testgroup);
       await database.groupDao.addGroup(group: testgroup);
@@ -139,58 +140,6 @@ void main() {
       expect(result.name, newGroupName);
     });
 
-    test('Adding player to group works correctly', () async {
-      await database.groupDao.addGroup(group: testgroup);
-
-      await database.playerGroupDao.addPlayerToGroup(
-        player: player4,
-        groupId: testgroup.id,
-      );
-
-      final playerAdded = await database.playerGroupDao.isPlayerInGroup(
-        playerId: player4.id,
-        groupId: testgroup.id,
-      );
-
-      expect(playerAdded, true);
-
-      final playerNotAdded = !await database.playerGroupDao.isPlayerInGroup(
-        playerId: '',
-        groupId: testgroup.id,
-      );
-
-      expect(playerNotAdded, true);
-
-      final result = await database.groupDao.getGroupById(
-        groupId: testgroup.id,
-      );
-      expect(result.members.length, testgroup.members.length + 1);
-
-      final addedPlayer = result.members.firstWhere((p) => p.id == player4.id);
-      expect(addedPlayer.name, player4.name);
-      expect(addedPlayer.createdAt, player4.createdAt);
-    });
-
-    test('Removing player from group works correctly', () async {
-      await database.groupDao.addGroup(group: testgroup);
-
-      final playerToRemove = testgroup.members[0];
-
-      final removed = await database.playerGroupDao.removePlayerFromGroup(
-        playerId: playerToRemove.id,
-        groupId: testgroup.id,
-      );
-      expect(removed, true);
-
-      final result = await database.groupDao.getGroupById(
-        groupId: testgroup.id,
-      );
-      expect(result.members.length, testgroup.members.length - 1);
-
-      final playerExists = result.members.any((p) => p.id == playerToRemove.id);
-      expect(playerExists, false);
-    });
-
     test('Getting the group count works correctly', () async {
       final initialCount = await database.groupDao.getGroupCount();
       expect(initialCount, 0);

test/db_tests/player_game_test.dart

@@ -0,0 +1,126 @@
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart';
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/dto/game.dart';
+import 'package:game_tracker/data/dto/group.dart';
+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 Group testgroup;
+  late Game testgameWithGroup;
+  late Game testgameWithPlayers;
+  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        // Recommended for widget tests to avoid test errors.
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    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');
+      testgroup = Group(
+        name: 'Test Group',
+        members: [player1, player2, player3],
+      );
+      testgameWithGroup = Game(name: 'Test Game', group: testgroup);
+      testgameWithPlayers = Game(
+        name: 'Test Game with Players',
+        players: [player4, player5, player6],
+      );
+    });
+  });
+  tearDown(() async {
+    await database.close();
+  });
+
+  group('Player-Game Tests', () {
+    test('Game has player works correctly', () async {
+      database.gameDao.addGame(game: testgameWithGroup);
+      database.playerDao.addPlayer(player: player1);
+
+      var gameHasPlayers = await database.playerGameDao.gameHasPlayers(
+        gameId: testgameWithGroup.id,
+      );
+
+      expect(gameHasPlayers, false);
+
+      database.playerGameDao.addPlayerToGame(
+        gameId: testgameWithGroup.id,
+        playerId: player1.id,
+      );
+
+      gameHasPlayers = await database.playerGameDao.gameHasPlayers(
+        gameId: testgameWithGroup.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.playerGameDao.addPlayerToGame(
+        gameId: testgameWithGroup.id,
+        playerId: player5.id,
+      );
+
+      var playerAdded = await database.playerGameDao.isPlayerInGame(
+        gameId: testgameWithGroup.id,
+        playerId: player5.id,
+      );
+
+      expect(playerAdded, true);
+
+      playerAdded = await database.playerGameDao.isPlayerInGame(
+        gameId: testgameWithGroup.id,
+        playerId: '',
+      );
+
+      expect(playerAdded, false);
+    });
+
+    test('Removing player from game works correctly', () async {
+      await database.gameDao.addGame(game: testgameWithPlayers);
+
+      final playerToRemove = testgameWithPlayers.players![0];
+
+      final removed = await database.playerGameDao.removePlayerFromGame(
+        playerId: playerToRemove.id,
+        gameId: testgameWithPlayers.id,
+      );
+      expect(removed, true);
+
+      final result = await database.gameDao.getGameById(
+        gameId: testgameWithGroup.id,
+      );
+      expect(result.players!.length, testgameWithGroup.players!.length - 1);
+
+      final playerExists = result.players!.any(
+        (p) => p.id == playerToRemove.id,
+      );
+      expect(playerExists, false);
+    });
+
+    //TODO: test getPlayersOfGame()
+    test('Retrieving players of a game works correctly', () async {});
+  });
+}

test/db_tests/player_group_test.dart

@@ -0,0 +1,90 @@
+import 'package:clock/clock.dart';
+import 'package:drift/drift.dart';
+import 'package:drift/native.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:game_tracker/data/db/database.dart';
+import 'package:game_tracker/data/dto/group.dart';
+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;
+  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
+  final fakeClock = Clock(() => fixedDate);
+
+  setUp(() {
+    database = AppDatabase(
+      DatabaseConnection(
+        NativeDatabase.memory(),
+        // Recommended for widget tests to avoid test errors.
+        closeStreamsSynchronously: true,
+      ),
+    );
+
+    withClock(fakeClock, () {
+      player1 = Player(name: 'Alice');
+      player2 = Player(name: 'Bob');
+      player3 = Player(name: 'Charlie');
+      player4 = Player(name: 'Diana');
+      testgroup = Group(
+        name: 'Test Group',
+        members: [player1, player2, player3],
+      );
+    });
+  });
+  tearDown(() async {
+    await database.close();
+  });
+
+  group('Player-Group Tests', () {
+    test('Adding a player to a group works correctly', () async {
+      await database.groupDao.addGroup(group: testgroup);
+      await database.playerDao.addPlayer(player: player4);
+      await database.playerGroupDao.addPlayerToGroup(
+        groupId: testgroup.id,
+        player: player4,
+      );
+
+      var playerAdded = await database.playerGroupDao.isPlayerInGroup(
+        groupId: testgroup.id,
+        playerId: player4.id,
+      );
+
+      expect(playerAdded, true);
+
+      playerAdded = await database.playerGroupDao.isPlayerInGroup(
+        groupId: testgroup.id,
+        playerId: '',
+      );
+
+      expect(playerAdded, false);
+    });
+
+    test('Removing player from group works correctly', () async {
+      await database.groupDao.addGroup(group: testgroup);
+
+      final playerToRemove = testgroup.members[0];
+
+      final removed = await database.playerGroupDao.removePlayerFromGroup(
+        playerId: playerToRemove.id,
+        groupId: testgroup.id,
+      );
+      expect(removed, true);
+
+      final result = await database.groupDao.getGroupById(
+        groupId: testgroup.id,
+      );
+      expect(result.members.length, testgroup.members.length - 1);
+
+      final playerExists = result.members.any((p) => p.id == playerToRemove.id);
+      expect(playerExists, false);
+    });
+
+    //TODO: test getPlayersOfGroup()
+    test('Retrieving players of a group works correctly', () async {});
+  });
+}

test/db_tests/player_test.dart

@@ -23,7 +23,7 @@ void main() {
 
     withClock(fakeClock, () {
       testPlayer = Player(name: 'Test Player');
-      testPlayer2 = Player(name: 'Second Group');
+      testPlayer2 = Player(name: 'Second Player');
     });
   });
   tearDown(() async {
@@ -52,6 +52,7 @@ void main() {
     });
 
     // TODO: Use upcoming addPlayers() method
+    // TODO: An Tests in Game orientieren
     test('Adding and fetching multiple players works correclty', () async {
       await database.playerDao.addPlayer(player: testPlayer);
       await database.playerDao.addPlayer(player: testPlayer2);