Added iteration for multiple items test

test/db_tests/game_test.dart

@@ -98,9 +98,8 @@ void main() {
       }
     });
 
-    // TODO: Use upcoming addGames() method
+    test('Adding and fetching multiple games works correctly', () async {
-    // TODO: Iterate through games
+      // TODO: Use upcoming addGames() method
-    test('Adding and fetching multiple games works correclty', () async {
       await database.gameDao.addGame(game: testgame1);
       await database.gameDao.addGame(game: testgame2);
       await database.gameDao.addGame(game: testgameWithGroup);
@@ -109,86 +108,61 @@ void main() {
       final allGames = await database.gameDao.getAllGames();
       expect(allGames.length, 4);
 
-      final fetchedGame1 = allGames.firstWhere((g) => g.id == testgame1.id);
+      final testGames = {
-      // game checks
+        testgame1.id: testgame1,
-      expect(fetchedGame1.id, testgame1.id);
+        testgame2.id: testgame2,
-      expect(fetchedGame1.name, testgame1.name);
+        testgameWithGroup.id: testgameWithGroup,
-      expect(fetchedGame1.createdAt, testgame1.createdAt);
+        testgameWithPlayer.id: testgameWithPlayer,
-      expect(fetchedGame1.winner, testgame1.winner);
+      };
 
-      // group checks
+      for (final game in allGames) {
-      expect(fetchedGame1.group!.id, testgame1.group!.id);
+        final expectedGame = testGames[game.id]!;
-      expect(fetchedGame1.group!.name, testgame1.group!.name);
-      expect(fetchedGame1.group!.createdAt, testgame1.group!.createdAt);
-      // group members checks
-      expect(
-        fetchedGame1.group!.members.length,
-        testgame1.group!.members.length,
-      );
-      for (int i = 0; i < testgame1.group!.members.length; i++) {
-        expect(
-          fetchedGame1.group!.members[i].id,
-          testgame1.group!.members[i].id,
-        );
-        expect(
-          fetchedGame1.group!.members[i].name,
-          testgame1.group!.members[i].name,
-        );
-        expect(
-          fetchedGame1.group!.members[i].createdAt,
-          testgame1.group!.members[i].createdAt,
-        );
-      }
 
-      // players checks
+        // Game-Checks
-      for (int i = 0; i < fetchedGame1.players!.length; i++) {
+        expect(game.id, expectedGame.id);
-        expect(fetchedGame1.players![i].id, testgame1.players![i].id);
+        expect(game.name, expectedGame.name);
-        expect(fetchedGame1.players![i].name, testgame1.players![i].name);
+        expect(game.createdAt, expectedGame.createdAt);
-        expect(
+        expect(game.winner, expectedGame.winner);
-          fetchedGame1.players![i].createdAt,
-          testgame1.players![i].createdAt,
-        );
-      }
 
-      final fetchedGame2 = allGames.firstWhere((g) => g.id == testgame2.id);
+        // Group-Checks
-      // game checks
+        if (expectedGame.group != null) {
-      expect(fetchedGame2.id, testgame2.id);
+          expect(game.group!.id, expectedGame.group!.id);
-      expect(fetchedGame2.name, testgame2.name);
+          expect(game.group!.name, expectedGame.group!.name);
-      expect(fetchedGame2.createdAt, testgame2.createdAt);
+          expect(game.group!.createdAt, expectedGame.group!.createdAt);
-      expect(fetchedGame2.winner, testgame2.winner);
 
-      // group checks
+          // Group Members-Checks
-      expect(fetchedGame2.group!.id, testgame2.group!.id);
+          expect(
-      expect(fetchedGame2.group!.name, testgame2.group!.name);
+            game.group!.members.length,
-      expect(fetchedGame2.group!.createdAt, testgame2.group!.createdAt);
+            expectedGame.group!.members.length,
-      // group members checks
+          );
-      expect(
+          for (int i = 0; i < expectedGame.group!.members.length; i++) {
-        fetchedGame2.group!.members.length,
+            expect(
-        testgame2.group!.members.length,
+              game.group!.members[i].id,
-      );
+              expectedGame.group!.members[i].id,
-      for (int i = 0; i < testgame2.group!.members.length; i++) {
+            );
-        expect(
+            expect(
-          fetchedGame2.group!.members[i].id,
+              game.group!.members[i].name,
-          testgame2.group!.members[i].id,
+              expectedGame.group!.members[i].name,
-        );
+            );
-        expect(
+            expect(
-          fetchedGame2.group!.members[i].name,
+              game.group!.members[i].createdAt,
-          testgame2.group!.members[i].name,
+              expectedGame.group!.members[i].createdAt,
-        );
+            );
-        expect(
+          }
-          fetchedGame2.group!.members[i].createdAt,
+        }
-          testgame2.group!.members[i].createdAt,
-        );
-      }
 
-      // players checks
+        // Players-Checks
-      for (int i = 0; i < fetchedGame2.players!.length; i++) {
+        if (expectedGame.players != null) {
-        expect(fetchedGame2.players![i].id, testgame2.players![i].id);
+          expect(game.players!.length, expectedGame.players!.length);
-        expect(fetchedGame2.players![i].name, testgame2.players![i].name);
+          for (int i = 0; i < expectedGame.players!.length; i++) {
-        expect(
+            expect(game.players![i].id, expectedGame.players![i].id);
-          fetchedGame2.players![i].createdAt,
+            expect(game.players![i].name, expectedGame.players![i].name);
-          testgame2.players![i].createdAt,
+            expect(
-        );
+              game.players![i].createdAt,
+              expectedGame.players![i].createdAt,
+            );
+          }
+        }
       }
     });
 

test/db_tests/group_test.dart

@@ -14,6 +14,8 @@ void main() {
   late Player player4;
   late Group testgroup;
   late Group testgroup2;
+  late Group testgroup3;
+  late Group testgroup4;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
@@ -40,6 +42,16 @@ void main() {
         name: 'Second Group',
         members: [player2, player3, player4],
       );
+      testgroup3 = Group(
+        id: 'gr2',
+        name: 'Second Group',
+        members: [player2, player4],
+      );
+      testgroup4 = Group(
+        id: 'gr2',
+        name: 'Second Group',
+        members: [player1, player2, player3, player4],
+      );
     });
   });
   tearDown(() async {
@@ -68,28 +80,37 @@ void main() {
       }
     });
 
-    test('Adding and fetching a single group works correctly', () async {
+    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);
 
       final allGroups = await database.groupDao.getAllGroups();
       expect(allGroups.length, 2);
 
-      final fetchedGroup1 = allGroups.firstWhere((g) => g.id == testgroup.id);
+      final testGroups = {testgroup.id: testgroup, testgroup2.id: testgroup2};
-      expect(fetchedGroup1.name, testgroup.name);
-      expect(fetchedGroup1.members.length, testgroup.members.length);
-      expect(fetchedGroup1.members.elementAt(0).id, player1.id);
-      expect(fetchedGroup1.members.elementAt(0).createdAt, player1.createdAt);
 
-      final fetchedGroup2 = allGroups.firstWhere((g) => g.id == testgroup2.id);
+      for (final group in allGroups) {
-      expect(fetchedGroup2.name, testgroup2.name);
+        final expectedGroup = testGroups[group.id]!;
-      expect(fetchedGroup2.members.length, testgroup2.members.length);
+
-      expect(fetchedGroup2.members.elementAt(0).id, player2.id);
+        expect(group.id, expectedGroup.id);
-      expect(fetchedGroup2.members.elementAt(0).createdAt, player2.createdAt);
+        expect(group.name, expectedGroup.name);
+        expect(group.createdAt, expectedGroup.createdAt);
+
+        expect(group.members.length, expectedGroup.members.length);
+        for (int i = 0; i < expectedGroup.members.length; i++) {
+          expect(group.members[i].id, expectedGroup.members[i].id);
+          expect(group.members[i].name, expectedGroup.members[i].name);
+          expect(
+            group.members[i].createdAt,
+            expectedGroup.members[i].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);

test/db_tests/player_test.dart

@@ -7,8 +7,10 @@ import 'package:game_tracker/data/dto/player.dart';
 
 void main() {
   late AppDatabase database;
-  late Player testPlayer;
+  late Player testPlayer1;
   late Player testPlayer2;
+  late Player testPlayer3;
+  late Player testPlayer4;
   final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
   final fakeClock = Clock(() => fixedDate);
 
@@ -22,27 +24,29 @@ void main() {
     );
 
     withClock(fakeClock, () {
-      testPlayer = Player(name: 'Test Player');
+      testPlayer1 = Player(name: 'Test Player');
       testPlayer2 = Player(name: 'Second Player');
+      testPlayer3 = Player(name: 'Charlie');
+      testPlayer4 = Player(name: 'Diana');
     });
   });
   tearDown(() async {
     await database.close();
   });
 
-  group('player tests', () {
+  group('Player Tests', () {
     test('Adding and fetching single player works correclty', () async {
-      await database.playerDao.addPlayer(player: testPlayer);
+      await database.playerDao.addPlayer(player: testPlayer1);
       await database.playerDao.addPlayer(player: testPlayer2);
 
       final allPlayers = await database.playerDao.getAllPlayers();
       expect(allPlayers.length, 2);
 
       final fetchedPlayer1 = allPlayers.firstWhere(
-        (g) => g.id == testPlayer.id,
+        (g) => g.id == testPlayer1.id,
       );
-      expect(fetchedPlayer1.name, testPlayer.name);
+      expect(fetchedPlayer1.name, testPlayer1.name);
-      expect(fetchedPlayer1.createdAt, testPlayer.createdAt);
+      expect(fetchedPlayer1.createdAt, testPlayer1.createdAt);
 
       final fetchedPlayer2 = allPlayers.firstWhere(
         (g) => g.id == testPlayer2.id,
@@ -51,31 +55,36 @@ void main() {
       expect(fetchedPlayer2.createdAt, testPlayer2.createdAt);
     });
 
-    // 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);
+      // TODO: Use upcoming addPlayers() method
+      await database.playerDao.addPlayer(player: testPlayer1);
       await database.playerDao.addPlayer(player: testPlayer2);
+      await database.playerDao.addPlayer(player: testPlayer3);
+      await database.playerDao.addPlayer(player: testPlayer4);
 
       final allPlayers = await database.playerDao.getAllPlayers();
-      expect(allPlayers.length, 2);
+      expect(allPlayers.length, 4);
 
-      final fetchedPlayer1 = allPlayers.firstWhere(
+      // Map for connencting fetched players with expected players
-        (g) => g.id == testPlayer.id,
+      final testPlayer = {
-      );
+        testPlayer1.id: testPlayer1,
-      expect(fetchedPlayer1.name, testPlayer.name);
+        testPlayer2.id: testPlayer2,
-      expect(fetchedPlayer1.createdAt, testPlayer.createdAt);
+        testPlayer3.id: testPlayer3,
+        testPlayer4.id: testPlayer4,
+      };
 
-      final fetchedPlayer2 = allPlayers.firstWhere(
+      for (final player in allPlayers) {
-        (g) => g.id == testPlayer2.id,
+        final expectedPlayer = testPlayer[player.id]!;
-      );
+
-      expect(fetchedPlayer2.name, testPlayer2.name);
+        expect(player.id, expectedPlayer.id);
-      expect(fetchedPlayer2.createdAt, testPlayer2.createdAt);
+        expect(player.name, expectedPlayer.name);
+        expect(player.createdAt, expectedPlayer.createdAt);
+      }
     });
 
     test('Adding the same player twice does not create duplicates', () async {
-      await database.playerDao.addPlayer(player: testPlayer);
+      await database.playerDao.addPlayer(player: testPlayer1);
-      await database.playerDao.addPlayer(player: testPlayer);
+      await database.playerDao.addPlayer(player: testPlayer1);
 
       final allPlayers = await database.playerDao.getAllPlayers();
       expect(allPlayers.length, 1);
@@ -83,43 +92,43 @@ void main() {
 
     test('Player existence check works correctly', () async {
       var playerExists = await database.playerDao.playerExists(
-        playerId: testPlayer.id,
+        playerId: testPlayer1.id,
       );
       expect(playerExists, false);
 
-      await database.playerDao.addPlayer(player: testPlayer);
+      await database.playerDao.addPlayer(player: testPlayer1);
 
       playerExists = await database.playerDao.playerExists(
-        playerId: testPlayer.id,
+        playerId: testPlayer1.id,
       );
       expect(playerExists, true);
     });
 
     test('Deleting a player works correclty', () async {
-      await database.playerDao.addPlayer(player: testPlayer);
+      await database.playerDao.addPlayer(player: testPlayer1);
       final playerDeleted = await database.playerDao.deletePlayer(
-        playerId: testPlayer.id,
+        playerId: testPlayer1.id,
       );
       expect(playerDeleted, true);
 
       final playerExists = await database.playerDao.playerExists(
-        playerId: testPlayer.id,
+        playerId: testPlayer1.id,
       );
       expect(playerExists, false);
     });
 
     test('Updating a player name works correcly', () async {
-      await database.playerDao.addPlayer(player: testPlayer);
+      await database.playerDao.addPlayer(player: testPlayer1);
 
       const newPlayerName = 'new player name';
 
       await database.playerDao.updatePlayername(
-        playerId: testPlayer.id,
+        playerId: testPlayer1.id,
         newName: newPlayerName,
       );
 
       final result = await database.playerDao.getPlayerById(
-        playerId: testPlayer.id,
+        playerId: testPlayer1.id,
       );
       expect(result.name, newPlayerName);
     });
@@ -128,7 +137,7 @@ void main() {
       var playerCount = await database.playerDao.getPlayerCount();
       expect(playerCount, 0);
 
-      await database.playerDao.addPlayer(player: testPlayer);
+      await database.playerDao.addPlayer(player: testPlayer1);
 
       playerCount = await database.playerDao.getPlayerCount();
       expect(playerCount, 1);
@@ -138,7 +147,7 @@ void main() {
       playerCount = await database.playerDao.getPlayerCount();
       expect(playerCount, 2);
 
-      await database.playerDao.deletePlayer(playerId: testPlayer.id);
+      await database.playerDao.deletePlayer(playerId: testPlayer1.id);
 
       playerCount = await database.playerDao.getPlayerCount();
       expect(playerCount, 1);