2026-01-09 12:55:50 +00:00
3 changed files with 251 additions and 55 deletions
--- a/test/db_tests/game_test.dart
+++ b/test/db_tests/game_test.dart
@@ -15,7 +15,9 @@ void main() {
  late Player player4;
  late Player player5;
  late Group testgroup;
+  late Group testgroup2;
  late Game testgame;
+  late Game testgame2;
  final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
  final fakeClock = Clock(() => fixedDate);

@@ -38,19 +40,28 @@ void main() {
        name: 'Test Group',
        members: [player1, player2, player3],
      );
+      testgroup2 = Group(
+        name: 'Test Group',
+        members: [player1, player2, player3],
+      );
      testgame = Game(
        name: 'Test Game',
        group: testgroup,
        players: [player4, player5],
      );
+      testgame2 = Game(
+        name: 'Second Test Game',
+        group: testgroup2,
+        players: [player1, player2, player3],
+      );
    });
  });
  tearDown(() async {
    await database.close();
  });

-  group('game tests', () {
-    test('game is added correctly', () async {
+  group('Game Tests', () {
+    test('Adding and fetching single game works correclty', () async {
      await database.gameDao.addGame(game: testgame);

      final result = await database.gameDao.getGameById(gameId: testgame.id);
@@ -83,7 +94,116 @@ void main() {
      }
    });

-    test('game is deleted correctly', () async {
+    // TODO: Use upcoming addGames() method
+    test('Adding and fetching multiple games works correclty', () async {
+      await database.gameDao.addGame(game: testgame);
+      await database.gameDao.addGame(game: testgame2);
+
+      final allGames = await database.gameDao.getAllGames();
+      expect(allGames.length, 2);
+
+      final fetchedGame1 = allGames.firstWhere((g) => g.id == testgame.id);
+      // game checks
+      expect(fetchedGame1.id, testgame.id);
+      expect(fetchedGame1.name, testgame.name);
+      expect(fetchedGame1.createdAt, testgame.createdAt);
+      expect(fetchedGame1.winner, testgame.winner);
+
+      // group checks
+      expect(fetchedGame1.group!.id, testgame.group!.id);
+      expect(fetchedGame1.group!.name, testgame.group!.name);
+      expect(fetchedGame1.group!.createdAt, testgame.group!.createdAt);
+      // group members checks
+      expect(
+        fetchedGame1.group!.members.length,
+        testgame.group!.members.length,
+      );
+      for (int i = 0; i < testgame.group!.members.length; i++) {
+        expect(
+          fetchedGame1.group!.members[i].id,
+          testgame.group!.members[i].id,
+        );
+        expect(
+          fetchedGame1.group!.members[i].name,
+          testgame.group!.members[i].name,
+        );
+        expect(
+          fetchedGame1.group!.members[i].createdAt,
+          testgame.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].createdAt,
+          testgame.players![i].createdAt,
+        );
+      }
+
+      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
+      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,
+        );
+      }
+
+      // 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,
+        );
+      }
+    });
+
+    test('Adding the same game twice does not create duplicates', () async {
+      await database.gameDao.addGame(game: testgame);
+      await database.gameDao.addGame(game: testgame);
+
+      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);
+      expect(gameExists, false);
+
+      await database.gameDao.addGame(game: testgame);
+
+      gameExists = await database.gameDao.gameExists(gameId: testgame.id);
+      expect(gameExists, true);
+    });
+
+    test('Deleting a game works correclty', () async {
      await database.gameDao.addGame(game: testgame);

      final gameDeleted = await database.gameDao.deleteGame(
@@ -95,22 +215,35 @@ void main() {
      expect(gameExists, false);
    });

-    test('get game count works correctly', () async {
-      final initialCount = await database.gameDao.getGameCount();
-      expect(initialCount, 0);
+    test('Getting the game count works correctly', () async {
+      var gameCount = await database.gameDao.getGameCount();
+      expect(gameCount, 0);

      await database.gameDao.addGame(game: testgame);

-      final gameAdded = await database.gameDao.getGameCount();
-      expect(gameAdded, 1);
+      gameCount = await database.gameDao.getGameCount();
+      expect(gameCount, 1);

-      final gameRemoved = await database.gameDao.deleteGame(
-        gameId: testgame.id,
-      );
-      expect(gameRemoved, true);
+      await database.gameDao.addGame(game: testgame2);

-      final finalCount = await database.gameDao.getGameCount();
-      expect(finalCount, 0);
+      gameCount = await database.gameDao.getGameCount();
+      expect(gameCount, 2);
+
+      await database.gameDao.deleteGame(gameId: testgame.id);
+
+      gameCount = await database.gameDao.getGameCount();
+      expect(gameCount, 1);
+
+      await database.gameDao.deleteGame(gameId: testgame2.id);
+
+      gameCount = await database.gameDao.getGameCount();
+      expect(gameCount, 0);
    });
+
+    // TODO: Implement
+    test('Adding a player to a game works correclty', () async {});
+
+    // TODO: Implement
+    test('Adding a group to a game works correclty', () async {});
  });
 }
--- a/test/db_tests/group_test.dart
+++ b/test/db_tests/group_test.dart
@@ -45,8 +45,31 @@ void main() {
  tearDown(() async {
    await database.close();
  });
-  group('group tests', () {
-    test('all groups get fetched correctly', () async {
+  group('Group Tests', () {
+    test('Adding and fetching a single group works correctly', () async {
+      await database.groupDao.addGroup(group: testgroup);
+
+      final fetchedGroup = await database.groupDao.getGroupById(
+        groupId: testgroup.id,
+      );
+
+      expect(fetchedGroup.id, testgroup.id);
+      expect(fetchedGroup.name, testgroup.name);
+      expect(fetchedGroup.createdAt, testgroup.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[i].createdAt,
+          testgroup.members[i].createdAt,
+        );
+      }
+    });
+
+    // 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);

@@ -66,26 +89,27 @@ void main() {
      expect(fetchedGroup2.members.elementAt(0).createdAt, player2.createdAt);
    });

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

-      final result = await database.groupDao.getGroupById(
-        groupId: testgroup.id,
-      );
-
-      expect(result.id, testgroup.id);
-      expect(result.name, testgroup.name);
-      expect(result.createdAt, testgroup.createdAt);
-
-      expect(result.members.length, testgroup.members.length);
-      for (int i = 0; i < testgroup.members.length; i++) {
-        expect(result.members[i].id, testgroup.members[i].id);
-        expect(result.members[i].name, testgroup.members[i].name);
-        expect(result.members[i].createdAt, testgroup.members[i].createdAt);
-      }
+      final allGroups = await database.groupDao.getAllGroups();
+      expect(allGroups.length, 1);
    });

-    test('group gets deleted correctly', () async {
+    test('Group existence check works correctly', () async {
+      var groupExists = await database.groupDao.groupExists(
+        groupId: testgroup.id,
+      );
+      expect(groupExists, false);
+
+      await database.groupDao.addGroup(group: testgroup);
+
+      groupExists = await database.groupDao.groupExists(groupId: testgroup.id);
+      expect(groupExists, true);
+    });
+
+    test('Deleting a group works correclty', () async {
      await database.groupDao.addGroup(group: testgroup);

      final groupDeleted = await database.groupDao.deleteGroup(
@@ -99,7 +123,7 @@ void main() {
      expect(groupExists, false);
    });

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

      const newGroupName = 'new group name';
@@ -167,7 +191,7 @@ void main() {
      expect(playerExists, false);
    });

-    test('get group count works correctly', () async {
+    test('Getting the group count works correctly', () async {
      final initialCount = await database.groupDao.getGroupCount();
      expect(initialCount, 0);

--- a/test/db_tests/player_test.dart
+++ b/test/db_tests/player_test.dart
@@ -31,7 +31,7 @@ void main() {
  });

  group('player tests', () {
-    test('all players get fetched correctly', () async {
+    test('Adding and fetching single player works correclty', () async {
      await database.playerDao.addPlayer(player: testPlayer);
      await database.playerDao.addPlayer(player: testPlayer2);

@@ -51,18 +51,50 @@ void main() {
      expect(fetchedPlayer2.createdAt, testPlayer2.createdAt);
    });

-    test('players get inserted correcly ', () async {
+    // TODO: Use upcoming addPlayers() method
+    test('Adding and fetching multiple players works correclty', () async {
      await database.playerDao.addPlayer(player: testPlayer);
-      final result = await database.playerDao.getPlayerById(
-        playerId: testPlayer.id,
-      );
+      await database.playerDao.addPlayer(player: testPlayer2);

-      expect(result.id, testPlayer.id);
-      expect(result.name, testPlayer.name);
-      expect(result.createdAt, testPlayer.createdAt);
+      final allPlayers = await database.playerDao.getAllPlayers();
+      expect(allPlayers.length, 2);
+
+      final fetchedPlayer1 = allPlayers.firstWhere(
+        (g) => g.id == testPlayer.id,
+      );
+      expect(fetchedPlayer1.name, testPlayer.name);
+      expect(fetchedPlayer1.createdAt, testPlayer.createdAt);
+
+      final fetchedPlayer2 = allPlayers.firstWhere(
+        (g) => g.id == testPlayer2.id,
+      );
+      expect(fetchedPlayer2.name, testPlayer2.name);
+      expect(fetchedPlayer2.createdAt, testPlayer2.createdAt);
    });

-    test('players get deleted correcly ', () async {
+    test('Adding the same player twice does not create duplicates', () async {
+      await database.playerDao.addPlayer(player: testPlayer);
+      await database.playerDao.addPlayer(player: testPlayer);
+
+      final allPlayers = await database.playerDao.getAllPlayers();
+      expect(allPlayers.length, 1);
+    });
+
+    test('Player existence check works correctly', () async {
+      var playerExists = await database.playerDao.playerExists(
+        playerId: testPlayer.id,
+      );
+      expect(playerExists, false);
+
+      await database.playerDao.addPlayer(player: testPlayer);
+
+      playerExists = await database.playerDao.playerExists(
+        playerId: testPlayer.id,
+      );
+      expect(playerExists, true);
+    });
+
+    test('Deleting a player works correclty', () async {
      await database.playerDao.addPlayer(player: testPlayer);
      final playerDeleted = await database.playerDao.deletePlayer(
        playerId: testPlayer.id,
@@ -75,7 +107,7 @@ void main() {
      expect(playerExists, false);
    });

-    test('player name gets updated correcly ', () async {
+    test('Updating a player name works correcly', () async {
      await database.playerDao.addPlayer(player: testPlayer);

      const newPlayerName = 'new player name';
@@ -91,22 +123,29 @@ void main() {
      expect(result.name, newPlayerName);
    });

-    test('get player count works correctly', () async {
-      final initialCount = await database.playerDao.getPlayerCount();
-      expect(initialCount, 0);
+    test('Getting the player count works correctly', () async {
+      var playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 0);

      await database.playerDao.addPlayer(player: testPlayer);

-      final playerAdded = await database.playerDao.getPlayerCount();
-      expect(playerAdded, 1);
+      playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 1);

-      final playerRemoved = await database.playerDao.deletePlayer(
-        playerId: testPlayer.id,
-      );
-      expect(playerRemoved, true);
+      await database.playerDao.addPlayer(player: testPlayer2);

-      final finalCount = await database.playerDao.getPlayerCount();
-      expect(finalCount, 0);
+      playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 2);
+
+      await database.playerDao.deletePlayer(playerId: testPlayer.id);
+
+      playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 1);
+
+      await database.playerDao.deletePlayer(playerId: testPlayer2.id);
+
+      playerCount = await database.playerDao.getPlayerCount();
+      expect(playerCount, 0);
    });
  });
 }