From a61818dd77613c3ed6294086963a1de23e0dbf78 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Thu, 20 Nov 2025 22:40:56 +0100 Subject: [PATCH 01/20] Fixed error in getAllGames method --- lib/data/dao/game_dao.dart | 22 +++++++++++++++++----- lib/data/dao/group_game_dao.dart | 9 +++++++-- lib/data/dao/player_game_dao.dart | 8 ++++---- 3 files changed, 28 insertions(+), 11 deletions(-) diff --git a/lib/data/dao/game_dao.dart b/lib/data/dao/game_dao.dart index 94d010c..20c90c7 100644 --- a/lib/data/dao/game_dao.dart +++ b/lib/data/dao/game_dao.dart @@ -15,11 +15,23 @@ class GameDao extends DatabaseAccessor with _$GameDaoMixin { Future> getAllGames() async { final query = select(gameTable); final result = await query.get(); - return result - .map( - (row) => Game(id: row.id, name: row.name, createdAt: row.createdAt), - ) - .toList(); + + return Future.wait( + result.map((row) async { + final group = await db.groupGameDao.getGroupByGameId(gameId: row.id); + final player = await db.playerGameDao.getPlayersByGameId( + gameId: row.id, + ); + return Game( + id: row.id, + name: row.name, + group: group, + players: player, + createdAt: row.createdAt, + winner: row.winnerId, + ); + }), + ); } /// Retrieves a [Game] by its [gameId]. diff --git a/lib/data/dao/group_game_dao.dart b/lib/data/dao/group_game_dao.dart index d3b30ca..66ebdec 100644 --- a/lib/data/dao/group_game_dao.dart +++ b/lib/data/dao/group_game_dao.dart @@ -23,10 +23,15 @@ class GroupGameDao extends DatabaseAccessor } /// Retrieves the [Group] associated with the given [gameId]. - Future getGroupByGameId({required String gameId}) async { + /// Returns `null` if no group is found. + Future getGroupByGameId({required String gameId}) async { final result = await (select( groupGameTable, - )..where((g) => g.gameId.equals(gameId))).getSingle(); + )..where((g) => g.gameId.equals(gameId))).getSingleOrNull(); + + if (result == null) { + return null; + } final group = await db.groupDao.getGroupById(groupId: result.groupId); return group; diff --git a/lib/data/dao/player_game_dao.dart b/lib/data/dao/player_game_dao.dart index 8f367f8..05c9e10 100644 --- a/lib/data/dao/player_game_dao.dart +++ b/lib/data/dao/player_game_dao.dart @@ -23,19 +23,19 @@ class PlayerGameDao extends DatabaseAccessor } /// Retrieves a list of [Player]s associated with the given [gameId]. - /// Returns an empty list if no players are found. - Future> getPlayersByGameId({required String gameId}) async { + /// Returns null if no players are found. + Future?> getPlayersByGameId({required String gameId}) async { final result = await (select( playerGameTable, )..where((p) => p.gameId.equals(gameId))).get(); - if (result.isEmpty) return []; + if (result.isEmpty) return null; final futures = result.map( (row) => db.playerDao.getPlayerById(playerId: row.playerId), ); final players = await Future.wait(futures); - return players.whereType().toList(); + return players; } /// Associates a player with a game by inserting a record into the -- 2.49.1 From 72067863c2c7d04f781159411e4b094726a08a72 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Thu, 20 Nov 2025 23:14:44 +0100 Subject: [PATCH 02/20] Updated insert modes --- lib/data/dao/group_game_dao.dart | 2 +- lib/data/dao/player_game_dao.dart | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/lib/data/dao/group_game_dao.dart b/lib/data/dao/group_game_dao.dart index 66ebdec..8a55b91 100644 --- a/lib/data/dao/group_game_dao.dart +++ b/lib/data/dao/group_game_dao.dart @@ -42,6 +42,6 @@ class GroupGameDao extends DatabaseAccessor Future addGroupToGame(String gameId, String groupId) async { await into( groupGameTable, - ).insert(GroupGameTableCompanion.insert(groupId: groupId, gameId: gameId)); + ).insert(GroupGameTableCompanion.insert(groupId: groupId, gameId: gameId), mode: InsertMode.insertOrReplace); } } diff --git a/lib/data/dao/player_game_dao.dart b/lib/data/dao/player_game_dao.dart index 05c9e10..92937cb 100644 --- a/lib/data/dao/player_game_dao.dart +++ b/lib/data/dao/player_game_dao.dart @@ -46,6 +46,7 @@ class PlayerGameDao extends DatabaseAccessor }) async { await into(playerGameTable).insert( PlayerGameTableCompanion.insert(playerId: playerId, gameId: gameId), + mode: InsertMode.insertOrReplace, ); } } -- 2.49.1 From 89b3f1ff69cc5e5e8fecad8e5536f602f1edb03a Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Thu, 20 Nov 2025 23:40:46 +0100 Subject: [PATCH 03/20] Overhauled tests --- test/db_tests/game_test.dart | 161 ++++++++++++++++++++++++++++++--- test/db_tests/group_test.dart | 64 +++++++++---- test/db_tests/player_test.dart | 81 ++++++++++++----- 3 files changed, 251 insertions(+), 55 deletions(-) diff --git a/test/db_tests/game_test.dart b/test/db_tests/game_test.dart index d726425..0b68648 100644 --- 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 {}); }); } diff --git a/test/db_tests/group_test.dart b/test/db_tests/group_test.dart index a076ab0..2572f52 100644 --- 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); diff --git a/test/db_tests/player_test.dart b/test/db_tests/player_test.dart index fa65f67..d894836 100644 --- 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); }); }); } -- 2.49.1 From 31589855f28e6eb8c6f2d402f389df8f9bfcf28b Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 00:06:09 +0100 Subject: [PATCH 04/20] Added methods of todos --- lib/data/dao/group_game_dao.dart | 57 +++++++++++++++++++-------- lib/data/dao/player_game_dao.dart | 64 +++++++++++++++++++++++-------- test/db_tests/game_test.dart | 59 ++++++++++++++++++++++++++-- 3 files changed, 143 insertions(+), 37 deletions(-) diff --git a/lib/data/dao/group_game_dao.dart b/lib/data/dao/group_game_dao.dart index 8a55b91..633bb1c 100644 --- a/lib/data/dao/group_game_dao.dart +++ b/lib/data/dao/group_game_dao.dart @@ -10,16 +10,13 @@ class GroupGameDao extends DatabaseAccessor with _$GroupGameDaoMixin { GroupGameDao(super.db); - /// Checks if there is a group associated with the given [gameId]. - /// Returns `true` if there is a group, otherwise `false`. - Future hasGameGroup({required String gameId}) async { - final count = - await (selectOnly(groupGameTable) - ..where(groupGameTable.gameId.equals(gameId)) - ..addColumns([groupGameTable.groupId.count()])) - .map((row) => row.read(groupGameTable.groupId.count())) - .getSingle(); - return (count ?? 0) > 0; + /// Associates a group with a game by inserting a record into the + /// [GroupGameTable]. + Future addGroupToGame(String gameId, String groupId) async { + await into(groupGameTable).insert( + GroupGameTableCompanion.insert(groupId: groupId, gameId: gameId), + mode: InsertMode.insertOrReplace, + ); } /// Retrieves the [Group] associated with the given [gameId]. @@ -37,11 +34,39 @@ class GroupGameDao extends DatabaseAccessor return group; } - /// Associates a group with a game by inserting a record into the - /// [GroupGameTable]. - Future addGroupToGame(String gameId, String groupId) async { - await into( - groupGameTable, - ).insert(GroupGameTableCompanion.insert(groupId: groupId, gameId: gameId), mode: InsertMode.insertOrReplace); + /// Checks if there is a group associated with the given [gameId]. + /// Returns `true` if there is a group, otherwise `false`. + Future gameHasGroup({required String gameId}) async { + final count = + await (selectOnly(groupGameTable) + ..where(groupGameTable.gameId.equals(gameId)) + ..addColumns([groupGameTable.groupId.count()])) + .map((row) => row.read(groupGameTable.groupId.count())) + .getSingle(); + return (count ?? 0) > 0; + } + + /// Checks if a specific group is associated with a specific game. + /// Returns `true` if the group is in the game, otherwise `false`. + Future isGroupInGame({ + required String gameId, + required String groupId, + }) async { + final count = + await (selectOnly(groupGameTable) + ..where( + groupGameTable.gameId.equals(gameId) & + groupGameTable.groupId.equals(groupId), + ) + ..addColumns([groupGameTable.groupId.count()])) + .map((row) => row.read(groupGameTable.groupId.count())) + .getSingle(); + return (count ?? 0) > 0; + } + + Future removeGroupFromGame({required String gameId}) async { + final query = delete(groupGameTable)..where((g) => g.gameId.equals(gameId)); + final rowsAffected = await query.go(); + return rowsAffected > 0; } } diff --git a/lib/data/dao/player_game_dao.dart b/lib/data/dao/player_game_dao.dart index 92937cb..87fd1d0 100644 --- a/lib/data/dao/player_game_dao.dart +++ b/lib/data/dao/player_game_dao.dart @@ -10,16 +10,16 @@ class PlayerGameDao extends DatabaseAccessor with _$PlayerGameDaoMixin { PlayerGameDao(super.db); - /// Checks if there are any players associated with the given [gameId]. - /// Returns `true` if there are players, otherwise `false`. - Future gameHasPlayers({required String gameId}) async { - final count = - await (selectOnly(playerGameTable) - ..where(playerGameTable.gameId.equals(gameId)) - ..addColumns([playerGameTable.playerId.count()])) - .map((row) => row.read(playerGameTable.playerId.count())) - .getSingle(); - return (count ?? 0) > 0; + /// Associates a player with a game by inserting a record into the + /// [PlayerGameTable]. + Future addPlayerToGame({ + required String gameId, + required String playerId, + }) async { + await into(playerGameTable).insert( + PlayerGameTableCompanion.insert(playerId: playerId, gameId: gameId), + mode: InsertMode.insertOrReplace, + ); } /// Retrieves a list of [Player]s associated with the given [gameId]. @@ -38,15 +38,45 @@ class PlayerGameDao extends DatabaseAccessor return players; } - /// Associates a player with a game by inserting a record into the - /// [PlayerGameTable]. - Future addPlayerToGame({ + /// Checks if there are any players associated with the given [gameId]. + /// Returns `true` if there are players, otherwise `false`. + Future gameHasPlayers({required String gameId}) async { + final count = + await (selectOnly(playerGameTable) + ..where(playerGameTable.gameId.equals(gameId)) + ..addColumns([playerGameTable.playerId.count()])) + .map((row) => row.read(playerGameTable.playerId.count())) + .getSingle(); + return (count ?? 0) > 0; + } + + /// Checks if a specific player is associated with a specific game. + /// Returns `true` if the player is in the game, otherwise `false`. + Future isPlayerInGame({ required String gameId, required String playerId, }) async { - await into(playerGameTable).insert( - PlayerGameTableCompanion.insert(playerId: playerId, gameId: gameId), - mode: InsertMode.insertOrReplace, - ); + final count = + await (selectOnly(playerGameTable) + ..where(playerGameTable.gameId.equals(gameId)) + ..where(playerGameTable.playerId.equals(playerId)) + ..addColumns([playerGameTable.playerId.count()])) + .map((row) => row.read(playerGameTable.playerId.count())) + .getSingle(); + return (count ?? 0) > 0; + } + + /// Removes the association of a player with a game by deleting the record + /// from the [PlayerGameTable]. + /// Returns `true` if more than 0 rows were affected, otherwise `false`. + Future removePlayerFromGame({ + required String gameId, + required String playerId, + }) async { + final query = delete(playerGameTable) + ..where((pg) => pg.gameId.equals(gameId)) + ..where((pg) => pg.playerId.equals(playerId)); + final rowsAffected = await query.go(); + return rowsAffected > 0; } } diff --git a/test/db_tests/game_test.dart b/test/db_tests/game_test.dart index 0b68648..05cf9d0 100644 --- a/test/db_tests/game_test.dart +++ b/test/db_tests/game_test.dart @@ -14,10 +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 testgame2; + late Game testgame3; final fixedDate = DateTime(2025, 19, 11, 00, 11, 23); final fakeClock = Clock(() => fixedDate); @@ -36,6 +38,7 @@ void main() { 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], @@ -54,6 +57,7 @@ void main() { group: testgroup2, players: [player1, player2, player3], ); + testgame3 = Game(name: 'Third Test Game', players: [player4, player5]); }); }); tearDown(() async { @@ -240,10 +244,57 @@ void main() { expect(gameCount, 0); }); - // TODO: Implement - test('Adding a player to a game works correclty', () async {}); + 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, + ); - // TODO: Implement - test('Adding a group to a game works correclty', () async {}); + 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); + }, + ); }); } -- 2.49.1 From 6055eb63a85ffb43143a63f4e9083aff1a718c1d Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 00:07:34 +0100 Subject: [PATCH 05/20] Refactoring --- lib/data/dao/game_dao.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/data/dao/game_dao.dart b/lib/data/dao/game_dao.dart index 20c90c7..2024eca 100644 --- a/lib/data/dao/game_dao.dart +++ b/lib/data/dao/game_dao.dart @@ -44,7 +44,7 @@ class GameDao extends DatabaseAccessor with _$GameDaoMixin { players = await db.playerGameDao.getPlayersByGameId(gameId: gameId); } Group? group; - if (await db.groupGameDao.hasGameGroup(gameId: gameId)) { + if (await db.groupGameDao.gameHasGroup(gameId: gameId)) { group = await db.groupGameDao.getGroupByGameId(gameId: gameId); } -- 2.49.1 From b21ca5467232c9e35b341ea5c374353c8ee77210 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 00:10:29 +0100 Subject: [PATCH 06/20] Refactoring --- lib/data/dao/game_dao.dart | 10 +++---- lib/data/dao/group_dao.dart | 4 +-- lib/data/dao/group_game_dao.dart | 2 +- lib/data/dao/player_game_dao.dart | 2 +- lib/data/dao/player_group_dao.dart | 48 +++++++++++++++--------------- 5 files changed, 32 insertions(+), 34 deletions(-) diff --git a/lib/data/dao/game_dao.dart b/lib/data/dao/game_dao.dart index 2024eca..f29d553 100644 --- a/lib/data/dao/game_dao.dart +++ b/lib/data/dao/game_dao.dart @@ -18,10 +18,8 @@ class GameDao extends DatabaseAccessor with _$GameDaoMixin { return Future.wait( result.map((row) async { - final group = await db.groupGameDao.getGroupByGameId(gameId: row.id); - final player = await db.playerGameDao.getPlayersByGameId( - gameId: row.id, - ); + final group = await db.groupGameDao.getGroupOfGame(gameId: row.id); + final player = await db.playerGameDao.getPlayersOfGame(gameId: row.id); return Game( id: row.id, name: row.name, @@ -41,11 +39,11 @@ class GameDao extends DatabaseAccessor with _$GameDaoMixin { List? players; if (await db.playerGameDao.gameHasPlayers(gameId: gameId)) { - players = await db.playerGameDao.getPlayersByGameId(gameId: gameId); + players = await db.playerGameDao.getPlayersOfGame(gameId: gameId); } Group? group; if (await db.groupGameDao.gameHasGroup(gameId: gameId)) { - group = await db.groupGameDao.getGroupByGameId(gameId: gameId); + group = await db.groupGameDao.getGroupOfGame(gameId: gameId); } return Game( diff --git a/lib/data/dao/group_dao.dart b/lib/data/dao/group_dao.dart index 3378948..9b16801 100644 --- a/lib/data/dao/group_dao.dart +++ b/lib/data/dao/group_dao.dart @@ -16,7 +16,7 @@ class GroupDao extends DatabaseAccessor with _$GroupDaoMixin { final result = await query.get(); return Future.wait( result.map((groupData) async { - final members = await db.playerGroupDao.getPlayersOfGroupById( + final members = await db.playerGroupDao.getPlayersOfGroup( groupId: groupData.id, ); return Group( @@ -34,7 +34,7 @@ class GroupDao extends DatabaseAccessor with _$GroupDaoMixin { final query = select(groupTable)..where((g) => g.id.equals(groupId)); final result = await query.getSingle(); - List members = await db.playerGroupDao.getPlayersOfGroupById( + List members = await db.playerGroupDao.getPlayersOfGroup( groupId: groupId, ); diff --git a/lib/data/dao/group_game_dao.dart b/lib/data/dao/group_game_dao.dart index 633bb1c..8081c6f 100644 --- a/lib/data/dao/group_game_dao.dart +++ b/lib/data/dao/group_game_dao.dart @@ -21,7 +21,7 @@ class GroupGameDao extends DatabaseAccessor /// Retrieves the [Group] associated with the given [gameId]. /// Returns `null` if no group is found. - Future getGroupByGameId({required String gameId}) async { + Future getGroupOfGame({required String gameId}) async { final result = await (select( groupGameTable, )..where((g) => g.gameId.equals(gameId))).getSingleOrNull(); diff --git a/lib/data/dao/player_game_dao.dart b/lib/data/dao/player_game_dao.dart index 87fd1d0..ef15a80 100644 --- a/lib/data/dao/player_game_dao.dart +++ b/lib/data/dao/player_game_dao.dart @@ -24,7 +24,7 @@ class PlayerGameDao extends DatabaseAccessor /// Retrieves a list of [Player]s associated with the given [gameId]. /// Returns null if no players are found. - Future?> getPlayersByGameId({required String gameId}) async { + Future?> getPlayersOfGame({required String gameId}) async { final result = await (select( playerGameTable, )..where((p) => p.gameId.equals(gameId))).get(); diff --git a/lib/data/dao/player_group_dao.dart b/lib/data/dao/player_group_dao.dart index fe067ae..5484bf7 100644 --- a/lib/data/dao/player_group_dao.dart +++ b/lib/data/dao/player_group_dao.dart @@ -10,8 +10,31 @@ class PlayerGroupDao extends DatabaseAccessor with _$PlayerGroupDaoMixin { PlayerGroupDao(super.db); + /// Adds a [player] to a group with the given [groupId]. + /// If the player is already in the group, no action is taken. + /// If the player does not exist in the player table, they are added. + /// Returns `true` if the player was added, otherwise `false`. + Future addPlayerToGroup({ + required Player player, + required String groupId, + }) async { + if (await isPlayerInGroup(playerId: player.id, groupId: groupId)) { + return false; + } + + if (await db.playerDao.playerExists(playerId: player.id) == false) { + db.playerDao.addPlayer(player: player); + } + + await into(playerGroupTable).insert( + PlayerGroupTableCompanion.insert(playerId: player.id, groupId: groupId), + ); + + return true; + } + /// Retrieves all players belonging to a specific group by [groupId]. - Future> getPlayersOfGroupById({required String groupId}) async { + Future> getPlayersOfGroup({required String groupId}) async { final query = select(playerGroupTable) ..where((pG) => pG.groupId.equals(groupId)); final result = await query.get(); @@ -38,29 +61,6 @@ class PlayerGroupDao extends DatabaseAccessor return rowsAffected > 0; } - /// Adds a [player] to a group with the given [groupId]. - /// If the player is already in the group, no action is taken. - /// If the player does not exist in the player table, they are added. - /// Returns `true` if the player was added, otherwise `false`. - Future addPlayerToGroup({ - required Player player, - required String groupId, - }) async { - if (await isPlayerInGroup(playerId: player.id, groupId: groupId)) { - return false; - } - - if (await db.playerDao.playerExists(playerId: player.id) == false) { - db.playerDao.addPlayer(player: player); - } - - await into(playerGroupTable).insert( - PlayerGroupTableCompanion.insert(playerId: player.id, groupId: groupId), - ); - - return true; - } - /// Checks if a player with [playerId] is in the group with [groupId]. /// Returns `true` if the player is in the group, otherwise `false`. Future isPlayerInGroup({ -- 2.49.1 From 961c6bb679b77492dcb60cb7a61e83c132fba855 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 01:05:35 +0100 Subject: [PATCH 07/20] Refactored tests in own files --- lib/data/dao/group_game_dao.dart | 11 +- test/db_tests/game_test.dart | 158 ++++++++++----------------- test/db_tests/group_game_test.dart | 110 +++++++++++++++++++ test/db_tests/group_test.dart | 55 +--------- test/db_tests/player_game_test.dart | 126 +++++++++++++++++++++ test/db_tests/player_group_test.dart | 90 +++++++++++++++ test/db_tests/player_test.dart | 3 +- 7 files changed, 394 insertions(+), 159 deletions(-) create mode 100644 test/db_tests/group_game_test.dart create mode 100644 test/db_tests/player_game_test.dart create mode 100644 test/db_tests/player_group_test.dart diff --git a/lib/data/dao/group_game_dao.dart b/lib/data/dao/group_game_dao.dart index 8081c6f..f3ddcc7 100644 --- a/lib/data/dao/group_game_dao.dart +++ b/lib/data/dao/group_game_dao.dart @@ -64,8 +64,15 @@ class GroupGameDao extends DatabaseAccessor return (count ?? 0) > 0; } - Future removeGroupFromGame({required String gameId}) async { - final query = delete(groupGameTable)..where((g) => g.gameId.equals(gameId)); + /// Removes the association of a group from a game based on [groupId] and + /// [gameId]. + /// Returns `true` if more than 0 rows were affected, otherwise `false`. + Future removeGroupFromGame({ + required String gameId, + required String groupId, + }) async { + final query = delete(groupGameTable) + ..where((g) => g.gameId.equals(gameId) & g.groupId.equals(groupId)); final rowsAffected = await query.go(); return rowsAffected > 0; } diff --git a/test/db_tests/game_test.dart b/test/db_tests/game_test.dart index 05cf9d0..d5b0856 100644 --- a/test/db_tests/game_test.dart +++ b/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); - }, - ); }); } diff --git a/test/db_tests/group_game_test.dart b/test/db_tests/group_game_test.dart new file mode 100644 index 0000000..2e208d9 --- /dev/null +++ b/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 {}); + }); +} diff --git a/test/db_tests/group_test.dart b/test/db_tests/group_test.dart index 2572f52..b18942e 100644 --- a/test/db_tests/group_test.dart +++ b/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); diff --git a/test/db_tests/player_game_test.dart b/test/db_tests/player_game_test.dart new file mode 100644 index 0000000..7df18a1 --- /dev/null +++ b/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 {}); + }); +} diff --git a/test/db_tests/player_group_test.dart b/test/db_tests/player_group_test.dart new file mode 100644 index 0000000..74d7658 --- /dev/null +++ b/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 {}); + }); +} diff --git a/test/db_tests/player_test.dart b/test/db_tests/player_test.dart index d894836..9430433 100644 --- a/test/db_tests/player_test.dart +++ b/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); -- 2.49.1 From fe9239ee02138fdf0751c069a928b1b41e61700d Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 12:45:48 +0100 Subject: [PATCH 08/20] Added missing test --- test/db_tests/group_game_test.dart | 22 ++++++++++++++++++++-- 1 file changed, 20 insertions(+), 2 deletions(-) diff --git a/test/db_tests/group_game_test.dart b/test/db_tests/group_game_test.dart index 2e208d9..6621d9a 100644 --- a/test/db_tests/group_game_test.dart +++ b/test/db_tests/group_game_test.dart @@ -104,7 +104,25 @@ void main() { expect(result.group, null); }); - // TODO: test getGroupOfGame() - test('Retrieving group of a game works correctly', () async {}); + test('Retrieving group of a game works correctly', () async { + await database.gameDao.addGame(game: gameWithGroup); + final group = await database.groupGameDao.getGroupOfGame( + gameId: gameWithGroup.id, + ); + + if (group == null) { + fail('Group should not be null'); + } + + expect(group.id, testgroup.id); + expect(group.name, testgroup.name); + expect(group.createdAt, testgroup.createdAt); + expect(group.members.length, testgroup.members.length); + for (int i = 0; i < group.members.length; i++) { + expect(group.members[i].id, testgroup.members[i].id); + expect(group.members[i].name, testgroup.members[i].name); + expect(group.members[i].createdAt, testgroup.members[i].createdAt); + } + }); }); } -- 2.49.1 From 229750ffcffda1c68ff2974b48c06fe138c30517 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 12:46:04 +0100 Subject: [PATCH 09/20] Fixed test --- test/db_tests/player_game_test.dart | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/db_tests/player_game_test.dart b/test/db_tests/player_game_test.dart index 7df18a1..d6f282e 100644 --- a/test/db_tests/player_game_test.dart +++ b/test/db_tests/player_game_test.dart @@ -110,9 +110,9 @@ void main() { expect(removed, true); final result = await database.gameDao.getGameById( - gameId: testgameWithGroup.id, + gameId: testgameWithPlayers.id, ); - expect(result.players!.length, testgameWithGroup.players!.length - 1); + expect(result.players!.length, testgameWithPlayers.players!.length - 1); final playerExists = result.players!.any( (p) => p.id == playerToRemove.id, -- 2.49.1 From 32f3f68da9083c2f60a9f664146d4b180de007bc Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 12:46:18 +0100 Subject: [PATCH 10/20] Annotation for missing test & method --- lib/data/dao/player_group_dao.dart | 3 +++ test/db_tests/player_group_test.dart | 3 +++ 2 files changed, 6 insertions(+) diff --git a/lib/data/dao/player_group_dao.dart b/lib/data/dao/player_group_dao.dart index 5484bf7..4024629 100644 --- a/lib/data/dao/player_group_dao.dart +++ b/lib/data/dao/player_group_dao.dart @@ -10,6 +10,9 @@ class PlayerGroupDao extends DatabaseAccessor with _$PlayerGroupDaoMixin { PlayerGroupDao(super.db); + /// No need for a groupHasPlayers method since the members attribute is + /// not nullable + /// Adds a [player] to a group with the given [groupId]. /// If the player is already in the group, no action is taken. /// If the player does not exist in the player table, they are added. diff --git a/test/db_tests/player_group_test.dart b/test/db_tests/player_group_test.dart index 74d7658..1181eda 100644 --- a/test/db_tests/player_group_test.dart +++ b/test/db_tests/player_group_test.dart @@ -41,6 +41,9 @@ void main() { }); group('Player-Group Tests', () { + /// No need to test if group has players since the members attribute is + /// not nullable + test('Adding a player to a group works correctly', () async { await database.groupDao.addGroup(group: testgroup); await database.playerDao.addPlayer(player: player4); -- 2.49.1 From e15f5d163db0b40c3bf1c5198e71d147e6f99035 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 13:12:36 +0100 Subject: [PATCH 11/20] Added missing methods --- test/db_tests/group_game_test.dart | 42 ++++++++++++++++------------ test/db_tests/player_game_test.dart | 18 ++++++++++-- test/db_tests/player_group_test.dart | 14 ++++++++-- 3 files changed, 52 insertions(+), 22 deletions(-) diff --git a/test/db_tests/group_game_test.dart b/test/db_tests/group_game_test.dart index 6621d9a..e231284 100644 --- a/test/db_tests/group_game_test.dart +++ b/test/db_tests/group_game_test.dart @@ -15,8 +15,8 @@ void main() { late Player player4; late Player player5; late Group testgroup; - late Game gameWithGroup; - late Game gameWithPlayers; + late Game testgameWithGroup; + late Game testgameWithPlayers; final fixedDate = DateTime(2025, 19, 11, 00, 11, 23); final fakeClock = Clock(() => fixedDate); @@ -39,11 +39,11 @@ void main() { name: 'Test Group', members: [player1, player2, player3], ); - gameWithPlayers = Game( + testgameWithPlayers = Game( name: 'Game with Players', players: [player4, player5], ); - gameWithGroup = Game(name: 'Game with Group', group: testgroup); + testgameWithGroup = Game(name: 'Game with Group', group: testgroup); }); }); tearDown(() async { @@ -51,63 +51,69 @@ void main() { }); group('Group-Game Tests', () { test('Game has group works correctly', () async { - database.gameDao.addGame(game: gameWithPlayers); + database.gameDao.addGame(game: testgameWithPlayers); database.groupDao.addGroup(group: testgroup); var gameHasGroup = await database.groupGameDao.gameHasGroup( - gameId: gameWithPlayers.id, + gameId: testgameWithPlayers.id, ); expect(gameHasGroup, false); - database.groupGameDao.addGroupToGame(gameWithPlayers.id, testgroup.id); + database.groupGameDao.addGroupToGame( + testgameWithPlayers.id, + testgroup.id, + ); gameHasGroup = await database.groupGameDao.gameHasGroup( - gameId: gameWithPlayers.id, + gameId: testgameWithPlayers.id, ); expect(gameHasGroup, true); }); test('Adding a group to a game works correctly', () async { - database.gameDao.addGame(game: gameWithPlayers); + database.gameDao.addGame(game: testgameWithPlayers); database.groupDao.addGroup(group: testgroup); - database.groupGameDao.addGroupToGame(gameWithPlayers.id, testgroup.id); + database.groupGameDao.addGroupToGame( + testgameWithPlayers.id, + testgroup.id, + ); var groupAdded = await database.groupGameDao.isGroupInGame( - gameId: gameWithPlayers.id, + gameId: testgameWithPlayers.id, groupId: testgroup.id, ); expect(groupAdded, true); groupAdded = await database.groupGameDao.isGroupInGame( - gameId: gameWithPlayers.id, + gameId: testgameWithPlayers.id, groupId: '', ); expect(groupAdded, false); }); test('Removing group from game works correctly', () async { - await database.gameDao.addGame(game: gameWithGroup); + await database.gameDao.addGame(game: testgameWithGroup); - final groupToRemove = gameWithGroup.group!; + final groupToRemove = testgameWithGroup.group!; final removed = await database.groupGameDao.removeGroupFromGame( groupId: groupToRemove.id, - gameId: gameWithGroup.id, + gameId: testgameWithGroup.id, ); expect(removed, true); final result = await database.gameDao.getGameById( - gameId: gameWithGroup.id, + gameId: testgameWithGroup.id, ); expect(result.group, null); }); test('Retrieving group of a game works correctly', () async { - await database.gameDao.addGame(game: gameWithGroup); + await database.gameDao.addGame(game: testgameWithGroup); final group = await database.groupGameDao.getGroupOfGame( - gameId: gameWithGroup.id, + gameId: testgameWithGroup.id, ); if (group == null) { diff --git a/test/db_tests/player_game_test.dart b/test/db_tests/player_game_test.dart index d6f282e..1fd0128 100644 --- a/test/db_tests/player_game_test.dart +++ b/test/db_tests/player_game_test.dart @@ -120,7 +120,21 @@ void main() { expect(playerExists, false); }); - //TODO: test getPlayersOfGame() - test('Retrieving players of a game works correctly', () async {}); + test('Retrieving players of a game works correctly', () async { + await database.gameDao.addGame(game: testgameWithPlayers); + final players = await database.playerGameDao.getPlayersOfGame( + gameId: testgameWithPlayers.id, + ); + + if (players == null) { + fail('Players should not be null'); + } + + 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); + } + }); }); } diff --git a/test/db_tests/player_group_test.dart b/test/db_tests/player_group_test.dart index 1181eda..9e367e0 100644 --- a/test/db_tests/player_group_test.dart +++ b/test/db_tests/player_group_test.dart @@ -87,7 +87,17 @@ void main() { expect(playerExists, false); }); - //TODO: test getPlayersOfGroup() - test('Retrieving players of a group works correctly', () async {}); + test('Retrieving players of a group works correctly', () async { + await database.groupDao.addGroup(group: testgroup); + final players = await database.playerGroupDao.getPlayersOfGroup( + groupId: testgroup.id, + ); + + for (int i = 0; i < players.length; i++) { + expect(players[i].id, testgroup.members[i].id); + expect(players[i].name, testgroup.members[i].name); + expect(players[i].createdAt, testgroup.members[i].createdAt); + } + }); }); } -- 2.49.1 From d948f2f13d6888996783f40b9761b87510c668f0 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 13:42:27 +0100 Subject: [PATCH 12/20] Added iteration for multiple items test --- test/db_tests/game_test.dart | 130 +++++++++++++-------------------- test/db_tests/group_test.dart | 47 ++++++++---- test/db_tests/player_test.dart | 77 ++++++++++--------- 3 files changed, 129 insertions(+), 125 deletions(-) diff --git a/test/db_tests/game_test.dart b/test/db_tests/game_test.dart index d5b0856..71b7573 100644 --- 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, + ); + } + } } }); diff --git a/test/db_tests/group_test.dart b/test/db_tests/group_test.dart index b18942e..189e4c3 100644 --- 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); diff --git a/test/db_tests/player_test.dart b/test/db_tests/player_test.dart index 9430433..aa5d09e 100644 --- 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); -- 2.49.1 From 8c0538520353ba9e42ff893a7f800d32591acf97 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 13:47:27 +0100 Subject: [PATCH 13/20] Renamed variables to be consistent --- test/db_tests/game_test.dart | 133 ++++++++++++++------------- test/db_tests/group_game_test.dart | 28 +++--- test/db_tests/group_test.dart | 96 +++++++++---------- test/db_tests/player_game_test.dart | 82 ++++++++--------- test/db_tests/player_group_test.dart | 24 ++--- 5 files changed, 183 insertions(+), 180 deletions(-) diff --git a/test/db_tests/game_test.dart b/test/db_tests/game_test.dart index 71b7573..a7163a3 100644 --- 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); diff --git a/test/db_tests/group_game_test.dart b/test/db_tests/group_game_test.dart index e231284..49d3cdb 100644 --- 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 { diff --git a/test/db_tests/group_test.dart b/test/db_tests/group_test.dart index 189e4c3..2cf9bba 100644 --- 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); diff --git a/test/db_tests/player_game_test.dart b/test/db_tests/player_game_test.dart index 1fd0128..0eca9ff 100644 --- 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); } }); }); diff --git a/test/db_tests/player_group_test.dart b/test/db_tests/player_group_test.dart index 9e367e0..2783430 100644 --- 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); -- 2.49.1 From dbb52cfc48546f69245297a0bf3b883d5bd8ba29 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 14:20:42 +0100 Subject: [PATCH 14/20] Added missing awaits --- test/db_tests/group_game_test.dart | 12 ++++++------ test/db_tests/player_game_test.dart | 10 +++++----- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/test/db_tests/group_game_test.dart b/test/db_tests/group_game_test.dart index 49d3cdb..1733243 100644 --- a/test/db_tests/group_game_test.dart +++ b/test/db_tests/group_game_test.dart @@ -51,8 +51,8 @@ void main() { }); group('Group-Game Tests', () { test('Game has group works correctly', () async { - database.gameDao.addGame(game: testgameWithPlayers); - database.groupDao.addGroup(group: testgroup); + await database.gameDao.addGame(game: testgameWithPlayers); + await database.groupDao.addGroup(group: testgroup); var gameHasGroup = await database.groupGameDao.gameHasGroup( gameId: testgameWithPlayers.id, @@ -60,7 +60,7 @@ void main() { expect(gameHasGroup, false); - database.groupGameDao.addGroupToGame( + await database.groupGameDao.addGroupToGame( testgameWithPlayers.id, testgroup.id, ); @@ -73,9 +73,9 @@ void main() { }); test('Adding a group to a game works correctly', () async { - database.gameDao.addGame(game: testgameWithPlayers); - database.groupDao.addGroup(group: testgroup); - database.groupGameDao.addGroupToGame( + await database.gameDao.addGame(game: testgameWithPlayers); + await database.groupDao.addGroup(group: testgroup); + await database.groupGameDao.addGroupToGame( testgameWithPlayers.id, testgroup.id, ); diff --git a/test/db_tests/player_game_test.dart b/test/db_tests/player_game_test.dart index 0eca9ff..f50afc1 100644 --- a/test/db_tests/player_game_test.dart +++ b/test/db_tests/player_game_test.dart @@ -54,8 +54,8 @@ void main() { group('Player-Game Tests', () { test('Game has player works correctly', () async { - database.gameDao.addGame(game: testGameOnlyGroup); - database.playerDao.addPlayer(player: testPlayer1); + await database.gameDao.addGame(game: testGameOnlyGroup); + await database.playerDao.addPlayer(player: testPlayer1); var gameHasPlayers = await database.playerGameDao.gameHasPlayers( gameId: testGameOnlyGroup.id, @@ -76,9 +76,9 @@ void main() { }); test('Adding a player to a game works correctly', () async { - database.gameDao.addGame(game: testGameOnlyGroup); - database.playerDao.addPlayer(player: testPlayer5); - database.playerGameDao.addPlayerToGame( + await database.gameDao.addGame(game: testGameOnlyGroup); + await database.playerDao.addPlayer(player: testPlayer5); + await database.playerGameDao.addPlayerToGame( gameId: testGameOnlyGroup.id, playerId: testPlayer5.id, ); -- 2.49.1 From ab250e2df43d1880d6d0e0c190a2ca00b7be76d2 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Fri, 21 Nov 2025 14:24:57 +0100 Subject: [PATCH 15/20] Typo --- test/db_tests/game_test.dart | 4 ++-- test/db_tests/group_test.dart | 2 +- test/db_tests/player_test.dart | 6 +++--- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/test/db_tests/game_test.dart b/test/db_tests/game_test.dart index a7163a3..311e30f 100644 --- a/test/db_tests/game_test.dart +++ b/test/db_tests/game_test.dart @@ -68,7 +68,7 @@ void main() { }); group('Game Tests', () { - test('Adding and fetching single game works correclty', () async { + test('Adding and fetching single game works correctly', () async { await database.gameDao.addGame(game: testGame1); final result = await database.gameDao.getGameById(gameId: testGame1.id); @@ -187,7 +187,7 @@ void main() { expect(gameExists, true); }); - test('Deleting a game works correclty', () async { + test('Deleting a game works correctly', () async { await database.gameDao.addGame(game: testGame1); final gameDeleted = await database.gameDao.deleteGame( diff --git a/test/db_tests/group_test.dart b/test/db_tests/group_test.dart index 2cf9bba..9104b74 100644 --- a/test/db_tests/group_test.dart +++ b/test/db_tests/group_test.dart @@ -131,7 +131,7 @@ void main() { expect(groupExists, true); }); - test('Deleting a group works correclty', () async { + test('Deleting a group works correctly', () async { await database.groupDao.addGroup(group: testGroup1); final groupDeleted = await database.groupDao.deleteGroup( diff --git a/test/db_tests/player_test.dart b/test/db_tests/player_test.dart index aa5d09e..2ec57e5 100644 --- a/test/db_tests/player_test.dart +++ b/test/db_tests/player_test.dart @@ -35,7 +35,7 @@ void main() { }); group('Player Tests', () { - test('Adding and fetching single player works correclty', () async { + test('Adding and fetching single player works correctly', () async { await database.playerDao.addPlayer(player: testPlayer1); await database.playerDao.addPlayer(player: testPlayer2); @@ -55,7 +55,7 @@ void main() { expect(fetchedPlayer2.createdAt, testPlayer2.createdAt); }); - test('Adding and fetching multiple players works correclty', () async { + test('Adding and fetching multiple players works correctly', () async { // TODO: Use upcoming addPlayers() method await database.playerDao.addPlayer(player: testPlayer1); await database.playerDao.addPlayer(player: testPlayer2); @@ -104,7 +104,7 @@ void main() { expect(playerExists, true); }); - test('Deleting a player works correclty', () async { + test('Deleting a player works correctly', () async { await database.playerDao.addPlayer(player: testPlayer1); final playerDeleted = await database.playerDao.deletePlayer( playerId: testPlayer1.id, -- 2.49.1 From 62eea086144522acde8a8396aa584f3dbd24b9b2 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Sat, 22 Nov 2025 14:12:41 +0100 Subject: [PATCH 16/20] Renamed variable --- lib/data/dao/game_dao.dart | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/data/dao/game_dao.dart b/lib/data/dao/game_dao.dart index f29d553..283c02f 100644 --- a/lib/data/dao/game_dao.dart +++ b/lib/data/dao/game_dao.dart @@ -19,12 +19,12 @@ class GameDao extends DatabaseAccessor with _$GameDaoMixin { return Future.wait( result.map((row) async { final group = await db.groupGameDao.getGroupOfGame(gameId: row.id); - final player = await db.playerGameDao.getPlayersOfGame(gameId: row.id); + final players = await db.playerGameDao.getPlayersOfGame(gameId: row.id); return Game( id: row.id, name: row.name, group: group, - players: player, + players: players, createdAt: row.createdAt, winner: row.winnerId, ); -- 2.49.1 From 24f18f5c655088ecfa127495d8e34e8592aa1b9d Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Sat, 22 Nov 2025 14:13:15 +0100 Subject: [PATCH 17/20] Removed false comparison --- lib/data/dao/player_group_dao.dart | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/data/dao/player_group_dao.dart b/lib/data/dao/player_group_dao.dart index 4024629..8cf96c2 100644 --- a/lib/data/dao/player_group_dao.dart +++ b/lib/data/dao/player_group_dao.dart @@ -25,7 +25,7 @@ class PlayerGroupDao extends DatabaseAccessor return false; } - if (await db.playerDao.playerExists(playerId: player.id) == false) { + if (!await db.playerDao.playerExists(playerId: player.id)) { db.playerDao.addPlayer(player: player); } -- 2.49.1 From bef812502cbe4ca7ed4a38974fb443bfc913232d Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Sat, 22 Nov 2025 14:20:51 +0100 Subject: [PATCH 18/20] Renamed variable and added null checks --- test/db_tests/game_test.dart | 53 ++++++++++++++++-------------------- 1 file changed, 24 insertions(+), 29 deletions(-) diff --git a/test/db_tests/game_test.dart b/test/db_tests/game_test.dart index 311e30f..7590a97 100644 --- a/test/db_tests/game_test.dart +++ b/test/db_tests/game_test.dart @@ -119,52 +119,47 @@ void main() { }; for (final game in allGames) { - final expectedGame = testGames[game.id]!; + final testGame = testGames[game.id]!; // Game-Checks - expect(game.id, expectedGame.id); - expect(game.name, expectedGame.name); - expect(game.createdAt, expectedGame.createdAt); - expect(game.winner, expectedGame.winner); + expect(game.id, testGame.id); + expect(game.name, testGame.name); + expect(game.createdAt, testGame.createdAt); + expect(game.winner, testGame.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); + if (testGame.group != null) { + expect(game.group!.id, testGame.group!.id); + expect(game.group!.name, testGame.group!.name); + expect(game.group!.createdAt, testGame.group!.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.length, testGame.group!.members.length); + for (int i = 0; i < testGame.group!.members.length; i++) { + expect(game.group!.members[i].id, testGame.group!.members[i].id); expect( game.group!.members[i].name, - expectedGame.group!.members[i].name, + testGame.group!.members[i].name, ); expect( game.group!.members[i].createdAt, - expectedGame.group!.members[i].createdAt, + testGame.group!.members[i].createdAt, ); } + } else { + expect(game.group, null); } // 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, - ); + if (testGame.players != null) { + expect(game.players!.length, testGame.players!.length); + for (int i = 0; i < testGame.players!.length; i++) { + expect(game.players![i].id, testGame.players![i].id); + expect(game.players![i].name, testGame.players![i].name); + expect(game.players![i].createdAt, testGame.players![i].createdAt); } + } else { + expect(game.players, null); } } }); -- 2.49.1 From 9346f61d141c1658e33101527e04ff6e88689f56 Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Sat, 22 Nov 2025 14:21:28 +0100 Subject: [PATCH 19/20] Renamed variable --- test/db_tests/group_test.dart | 21 +++++++++------------ 1 file changed, 9 insertions(+), 12 deletions(-) diff --git a/test/db_tests/group_test.dart b/test/db_tests/group_test.dart index 9104b74..6c8e6c9 100644 --- a/test/db_tests/group_test.dart +++ b/test/db_tests/group_test.dart @@ -93,20 +93,17 @@ void main() { final testGroups = {testGroup1.id: testGroup1, testGroup2.id: testGroup2}; for (final group in allGroups) { - final expectedGroup = testGroups[group.id]!; + final testGroup = testGroups[group.id]!; - expect(group.id, expectedGroup.id); - expect(group.name, expectedGroup.name); - expect(group.createdAt, expectedGroup.createdAt); + expect(group.id, testGroup.id); + expect(group.name, testGroup.name); + expect(group.createdAt, testGroup.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, - ); + expect(group.members.length, testGroup.members.length); + for (int i = 0; i < testGroup.members.length; i++) { + expect(group.members[i].id, testGroup.members[i].id); + expect(group.members[i].name, testGroup.members[i].name); + expect(group.members[i].createdAt, testGroup.members[i].createdAt); } } }); -- 2.49.1 From 30645f06f82c2c7cf20f9f79d1bb1f22aef3d59f Mon Sep 17 00:00:00 2001 From: Felix Kirchner Date: Sat, 22 Nov 2025 14:21:55 +0100 Subject: [PATCH 20/20] Renamed variable --- test/db_tests/player_test.dart | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/test/db_tests/player_test.dart b/test/db_tests/player_test.dart index 2ec57e5..30d9a14 100644 --- a/test/db_tests/player_test.dart +++ b/test/db_tests/player_test.dart @@ -66,7 +66,7 @@ void main() { expect(allPlayers.length, 4); // Map for connencting fetched players with expected players - final testPlayer = { + final testPlayers = { testPlayer1.id: testPlayer1, testPlayer2.id: testPlayer2, testPlayer3.id: testPlayer3, @@ -74,11 +74,11 @@ void main() { }; for (final player in allPlayers) { - final expectedPlayer = testPlayer[player.id]!; + final testPlayer = testPlayers[player.id]!; - expect(player.id, expectedPlayer.id); - expect(player.name, expectedPlayer.name); - expect(player.createdAt, expectedPlayer.createdAt); + expect(player.id, testPlayer.id); + expect(player.name, testPlayer.name); + expect(player.createdAt, testPlayer.createdAt); } }); -- 2.49.1