Added iteration for multiple items test

2025-11-21 13:42:27 +01:00
parent e15f5d163d
commit d948f2f13d
3 changed files with 129 additions and 125 deletions
--- a/test/db_tests/game_test.dart
+++ b/test/db_tests/game_test.dart
@@ -98,9 +98,8 @@ void main() {
      }
    });

-    // TODO: Use upcoming addGames() method
-    // TODO: Iterate through games
-    test('Adding and fetching multiple games works correclty', () async {
+    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);
@@ -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);
-      // game checks
-      expect(fetchedGame1.id, testgame1.id);
-      expect(fetchedGame1.name, testgame1.name);
-      expect(fetchedGame1.createdAt, testgame1.createdAt);
-      expect(fetchedGame1.winner, testgame1.winner);
+      final testGames = {
+        testgame1.id: testgame1,
+        testgame2.id: testgame2,
+        testgameWithGroup.id: testgameWithGroup,
+        testgameWithPlayer.id: testgameWithPlayer,
+      };

-      // group checks
-      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,
-        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,
-        );
-      }
+      for (final game in allGames) {
+        final expectedGame = testGames[game.id]!;

-      // players checks
-      for (int i = 0; i < fetchedGame1.players!.length; i++) {
-        expect(fetchedGame1.players![i].id, testgame1.players![i].id);
-        expect(fetchedGame1.players![i].name, testgame1.players![i].name);
-        expect(
-          fetchedGame1.players![i].createdAt,
-          testgame1.players![i].createdAt,
-        );
-      }
+        // Game-Checks
+        expect(game.id, expectedGame.id);
+        expect(game.name, expectedGame.name);
+        expect(game.createdAt, expectedGame.createdAt);
+        expect(game.winner, expectedGame.winner);

-      final fetchedGame2 = allGames.firstWhere((g) => g.id == testgame2.id);
-      // game checks
-      expect(fetchedGame2.id, testgame2.id);
-      expect(fetchedGame2.name, testgame2.name);
-      expect(fetchedGame2.createdAt, testgame2.createdAt);
-      expect(fetchedGame2.winner, testgame2.winner);
+        // Group-Checks
+        if (expectedGame.group != null) {
+          expect(game.group!.id, expectedGame.group!.id);
+          expect(game.group!.name, expectedGame.group!.name);
+          expect(game.group!.createdAt, expectedGame.group!.createdAt);

-      // group checks
-      expect(fetchedGame2.group!.id, testgame2.group!.id);
-      expect(fetchedGame2.group!.name, testgame2.group!.name);
-      expect(fetchedGame2.group!.createdAt, testgame2.group!.createdAt);
-      // group members checks
-      expect(
-        fetchedGame2.group!.members.length,
-        testgame2.group!.members.length,
-      );
-      for (int i = 0; i < testgame2.group!.members.length; i++) {
-        expect(
-          fetchedGame2.group!.members[i].id,
-          testgame2.group!.members[i].id,
-        );
-        expect(
-          fetchedGame2.group!.members[i].name,
-          testgame2.group!.members[i].name,
-        );
-        expect(
-          fetchedGame2.group!.members[i].createdAt,
-          testgame2.group!.members[i].createdAt,
-        );
-      }
+          // Group Members-Checks
+          expect(
+            game.group!.members.length,
+            expectedGame.group!.members.length,
+          );
+          for (int i = 0; i < expectedGame.group!.members.length; i++) {
+            expect(
+              game.group!.members[i].id,
+              expectedGame.group!.members[i].id,
+            );
+            expect(
+              game.group!.members[i].name,
+              expectedGame.group!.members[i].name,
+            );
+            expect(
+              game.group!.members[i].createdAt,
+              expectedGame.group!.members[i].createdAt,
+            );
+          }
+        }

-      // players checks
-      for (int i = 0; i < fetchedGame2.players!.length; i++) {
-        expect(fetchedGame2.players![i].id, testgame2.players![i].id);
-        expect(fetchedGame2.players![i].name, testgame2.players![i].name);
-        expect(
-          fetchedGame2.players![i].createdAt,
-          testgame2.players![i].createdAt,
-        );
+        // Players-Checks
+        if (expectedGame.players != null) {
+          expect(game.players!.length, expectedGame.players!.length);
+          for (int i = 0; i < expectedGame.players!.length; i++) {
+            expect(game.players![i].id, expectedGame.players![i].id);
+            expect(game.players![i].name, expectedGame.players![i].name);
+            expect(
+              game.players![i].createdAt,
+              expectedGame.players![i].createdAt,
+            );
+          }
+        }
      }
    });

--- a/test/db_tests/group_test.dart
+++ b/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);
-      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 testGroups = {testgroup.id: testgroup, testgroup2.id: testgroup2};

-      final fetchedGroup2 = allGroups.firstWhere((g) => g.id == testgroup2.id);
-      expect(fetchedGroup2.name, testgroup2.name);
-      expect(fetchedGroup2.members.length, testgroup2.members.length);
-      expect(fetchedGroup2.members.elementAt(0).id, player2.id);
-      expect(fetchedGroup2.members.elementAt(0).createdAt, player2.createdAt);
+      for (final group in allGroups) {
+        final expectedGroup = testGroups[group.id]!;
+
+        expect(group.id, expectedGroup.id);
+        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);
--- a/test/db_tests/player_test.dart
+++ b/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.createdAt, testPlayer.createdAt);
+      expect(fetchedPlayer1.name, testPlayer1.name);
+      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(
-        (g) => g.id == testPlayer.id,
-      );
-      expect(fetchedPlayer1.name, testPlayer.name);
-      expect(fetchedPlayer1.createdAt, testPlayer.createdAt);
+      // Map for connencting fetched players with expected players
+      final testPlayer = {
+        testPlayer1.id: testPlayer1,
+        testPlayer2.id: testPlayer2,
+        testPlayer3.id: testPlayer3,
+        testPlayer4.id: testPlayer4,
+      };

-      final fetchedPlayer2 = allPlayers.firstWhere(
-        (g) => g.id == testPlayer2.id,
-      );
-      expect(fetchedPlayer2.name, testPlayer2.name);
-      expect(fetchedPlayer2.createdAt, testPlayer2.createdAt);
+      for (final player in allPlayers) {
+        final expectedPlayer = testPlayer[player.id]!;
+
+        expect(player.id, expectedPlayer.id);
+        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: testPlayer);
+      await database.playerDao.addPlayer(player: testPlayer1);
+      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);