diff --git a/lib/data/dao/game_dao.dart b/lib/data/dao/game_dao.dart index a948854..12893db 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.hasGameGroup(gameId: gameId)) { - group = await db.groupGameDao.getGroupByGameId(gameId: gameId); + if (await db.groupGameDao.gameHasGroup(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 695d78a..3489f5c 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 8a55b91..f3ddcc7 100644 --- a/lib/data/dao/group_game_dao.dart +++ b/lib/data/dao/group_game_dao.dart @@ -10,21 +10,18 @@ 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]. /// 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(); @@ -37,11 +34,46 @@ 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; + } + + /// 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/lib/data/dao/player_game_dao.dart b/lib/data/dao/player_game_dao.dart index 92937cb..ef15a80 100644 --- a/lib/data/dao/player_game_dao.dart +++ b/lib/data/dao/player_game_dao.dart @@ -10,21 +10,21 @@ 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]. /// 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(); @@ -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/lib/data/dao/player_group_dao.dart b/lib/data/dao/player_group_dao.dart index 93acf0b..4024629 100644 --- a/lib/data/dao/player_group_dao.dart +++ b/lib/data/dao/player_group_dao.dart @@ -10,8 +10,34 @@ 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. + /// 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,30 +64,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) { - await db.playerDao.addPlayer(player: player); - } - - await into(playerGroupTable).insert( - PlayerGroupTableCompanion.insert(playerId: player.id, groupId: groupId), - mode: InsertMode.insertOrReplace, - ); - - 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({ diff --git a/test/db_tests/game_test.dart b/test/db_tests/game_test.dart index 477965f..a7163a3 100644 --- a/test/db_tests/game_test.dart +++ b/test/db_tests/game_test.dart @@ -9,15 +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 testgame; - late Game testgame2; + 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); @@ -31,29 +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( - name: 'Test Group', - members: [player1, player2, player3], + 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: [testPlayer1, testPlayer2, testPlayer3], ); - testgroup2 = Group( - name: 'Test Group', - members: [player1, player2, player3], + testGroup2 = Group( + name: 'Test Group 2', + members: [testPlayer4, testPlayer5], ); - testgame = Game( - name: 'Test Game', - group: testgroup, - players: [player4, player5], + testGame1 = Game( + name: 'First Test Game', + group: testGroup1, + players: [testPlayer4, testPlayer5], ); - testgame2 = Game( + testGame2 = Game( name: 'Second Test Game', - group: testgroup2, - players: [player1, player2, player3], + group: testGroup2, + players: [testPlayer1, testPlayer2, testPlayer3], ); + testGameOnlyPlayers = Game( + name: 'Test Game with Players', + players: [testPlayer1, testPlayer2, testPlayer3], + ); + testGameOnlyGroup = Game(name: 'Test Game with Group', group: testGroup2); }); }); tearDown(() async { @@ -62,154 +69,135 @@ 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); + 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, 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'); } }); - test('Adding and fetching multiple games works correclty', () async { - await database.gameDao.addGames(games: [testgame, testgame2]); + 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: testGameOnlyGroup); + await database.gameDao.addGame(game: testGameOnlyPlayers); final allGames = await database.gameDao.getAllGames(); - expect(allGames.length, 2); + expect(allGames.length, 4); - 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); + final testGames = { + testGame1.id: testGame1, + testGame2.id: testGame2, + testGameOnlyGroup.id: testGameOnlyGroup, + testGameOnlyPlayers.id: testGameOnlyPlayers, + }; - // 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, - ); - } + 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, testgame.players![i].id); - expect(fetchedGame1.players![i].name, testgame.players![i].name); - expect( - fetchedGame1.players![i].createdAt, - testgame.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, + ); + } + } } }); 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); }); @@ -217,31 +205,25 @@ 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); - 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: testgame.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); }); - - // 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_game_test.dart b/test/db_tests/group_game_test.dart new file mode 100644 index 0000000..49d3cdb --- /dev/null +++ b/test/db_tests/group_game_test.dart @@ -0,0 +1,134 @@ +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 testPlayer1; + late Player testPlayer2; + late Player testPlayer3; + late Player testPlayer4; + late Player testPlayer5; + 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, () { + 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: [testPlayer1, testPlayer2, testPlayer3], + ); + testgameWithPlayers = Game( + name: 'Test Game with Players', + players: [testPlayer4, testPlayer5], + ); + testgameWithGroup = Game(name: 'Test 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: testgameWithPlayers); + database.groupDao.addGroup(group: testgroup); + + var gameHasGroup = await database.groupGameDao.gameHasGroup( + gameId: testgameWithPlayers.id, + ); + + expect(gameHasGroup, false); + + database.groupGameDao.addGroupToGame( + testgameWithPlayers.id, + testgroup.id, + ); + + gameHasGroup = await database.groupGameDao.gameHasGroup( + gameId: testgameWithPlayers.id, + ); + + expect(gameHasGroup, true); + }); + + test('Adding a group to a game works correctly', () async { + database.gameDao.addGame(game: testgameWithPlayers); + database.groupDao.addGroup(group: testgroup); + database.groupGameDao.addGroupToGame( + testgameWithPlayers.id, + testgroup.id, + ); + + var groupAdded = await database.groupGameDao.isGroupInGame( + gameId: testgameWithPlayers.id, + groupId: testgroup.id, + ); + expect(groupAdded, true); + + groupAdded = await database.groupGameDao.isGroupInGame( + gameId: testgameWithPlayers.id, + groupId: '', + ); + expect(groupAdded, false); + }); + + test('Removing group from game works correctly', () async { + await database.gameDao.addGame(game: testgameWithGroup); + + final groupToRemove = testgameWithGroup.group!; + + final removed = await database.groupGameDao.removeGroupFromGame( + groupId: groupToRemove.id, + gameId: testgameWithGroup.id, + ); + expect(removed, true); + + final result = await database.gameDao.getGameById( + gameId: testgameWithGroup.id, + ); + expect(result.group, null); + }); + + test('Retrieving group of a game works correctly', () async { + await database.gameDao.addGame(game: testgameWithGroup); + final group = await database.groupGameDao.getGroupOfGame( + gameId: testgameWithGroup.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); + } + }); + }); +} diff --git a/test/db_tests/group_test.dart b/test/db_tests/group_test.dart index 62416fd..2cf9bba 100644 --- a/test/db_tests/group_test.dart +++ b/test/db_tests/group_test.dart @@ -8,12 +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 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); @@ -27,18 +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( + id: 'gr2', + name: 'Second Group', + members: [testPlayer2, testPlayer4], + ); + testGroup4 = Group( + id: 'gr2', + name: 'Second Group', + members: [testPlayer1, testPlayer2, testPlayer3, testPlayer4], ); }); }); @@ -47,49 +59,61 @@ 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 a single group works correctly', () async { - await database.groupDao.addGroups(groups: [testgroup, testgroup2]); + test('Adding and fetching multiple groups works correctly', () async { + // TODO: Use upcoming addGroups() method + 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 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 = {testGroup1.id: testGroup1, 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, + ); + } + } }); 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); @@ -97,109 +121,57 @@ 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); }); - 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); - 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 new file mode 100644 index 0000000..0eca9ff --- /dev/null +++ b/test/db_tests/player_game_test.dart @@ -0,0 +1,140 @@ +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 testPlayer1; + late Player testPlayer2; + late Player testPlayer3; + late Player testPlayer4; + late Player testPlayer5; + late Player testPlayer6; + late Group testgroup; + late Game testGameOnlyGroup; + late Game testGameOnlyPlayers; + 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, () { + 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: [testPlayer1, testPlayer2, testPlayer3], + ); + testGameOnlyGroup = Game(name: 'Test Game with Group', group: testgroup); + testGameOnlyPlayers = Game( + name: 'Test Game with Players', + players: [testPlayer4, testPlayer5, testPlayer6], + ); + }); + }); + tearDown(() async { + await database.close(); + }); + + group('Player-Game Tests', () { + test('Game has player works correctly', () async { + database.gameDao.addGame(game: testGameOnlyGroup); + database.playerDao.addPlayer(player: testPlayer1); + + var gameHasPlayers = await database.playerGameDao.gameHasPlayers( + gameId: testGameOnlyGroup.id, + ); + + expect(gameHasPlayers, false); + + database.playerGameDao.addPlayerToGame( + gameId: testGameOnlyGroup.id, + playerId: testPlayer1.id, + ); + + gameHasPlayers = await database.playerGameDao.gameHasPlayers( + gameId: testGameOnlyGroup.id, + ); + + expect(gameHasPlayers, true); + }); + + test('Adding a player to a game works correctly', () async { + database.gameDao.addGame(game: testGameOnlyGroup); + database.playerDao.addPlayer(player: testPlayer5); + database.playerGameDao.addPlayerToGame( + gameId: testGameOnlyGroup.id, + playerId: testPlayer5.id, + ); + + var playerAdded = await database.playerGameDao.isPlayerInGame( + gameId: testGameOnlyGroup.id, + playerId: testPlayer5.id, + ); + + expect(playerAdded, true); + + playerAdded = await database.playerGameDao.isPlayerInGame( + gameId: testGameOnlyGroup.id, + playerId: '', + ); + + expect(playerAdded, false); + }); + + test('Removing player from game works correctly', () async { + await database.gameDao.addGame(game: testGameOnlyPlayers); + + final playerToRemove = testGameOnlyPlayers.players![0]; + + final removed = await database.playerGameDao.removePlayerFromGame( + playerId: playerToRemove.id, + gameId: testGameOnlyPlayers.id, + ); + expect(removed, true); + + final result = await database.gameDao.getGameById( + gameId: testGameOnlyPlayers.id, + ); + expect(result.players!.length, testGameOnlyPlayers.players!.length - 1); + + final playerExists = result.players!.any( + (p) => p.id == playerToRemove.id, + ); + expect(playerExists, false); + }); + + test('Retrieving players of a game works correctly', () async { + await database.gameDao.addGame(game: testGameOnlyPlayers); + final players = await database.playerGameDao.getPlayersOfGame( + gameId: testGameOnlyPlayers.id, + ); + + if (players == null) { + fail('Players should not be null'); + } + + for (int i = 0; i < players.length; i++) { + 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 new file mode 100644 index 0000000..2783430 --- /dev/null +++ b/test/db_tests/player_group_test.dart @@ -0,0 +1,103 @@ +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 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); + + setUp(() { + database = AppDatabase( + DatabaseConnection( + NativeDatabase.memory(), + // Recommended for widget tests to avoid test errors. + closeStreamsSynchronously: true, + ), + ); + + withClock(fakeClock, () { + testPlayer1 = Player(name: 'Alice'); + testPlayer2 = Player(name: 'Bob'); + testPlayer3 = Player(name: 'Charlie'); + testPlayer4 = Player(name: 'Diana'); + testgroup = Group( + name: 'Test Group', + members: [testPlayer1, testPlayer2, testPlayer3], + ); + }); + }); + tearDown(() async { + await database.close(); + }); + + 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: testPlayer4); + await database.playerGroupDao.addPlayerToGroup( + groupId: testgroup.id, + player: testPlayer4, + ); + + var playerAdded = await database.playerGroupDao.isPlayerInGroup( + groupId: testgroup.id, + playerId: testPlayer4.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); + }); + + 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); + } + }); + }); +} diff --git a/test/db_tests/player_test.dart b/test/db_tests/player_test.dart index bc95533..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'); - testPlayer2 = Player(name: 'Second Group'); + 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, @@ -52,27 +56,35 @@ void main() { }); test('Adding and fetching multiple players works correclty', () async { - await database.playerDao.addPlayers(players: [testPlayer, testPlayer2]); + // 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); @@ -80,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); }); @@ -125,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); @@ -135,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);