liquid-development/game-tracker
3
0
Fork 0
Code Issues 13 Pull Requests 6 Actions Releases 1 Activity

Merge branch 'bug/37-getallgames-returnt-nicht-alle-attribute-von-der-game-klasse' into feature/31-json-import-fuer-testdaten

Browse Source 
# Conflicts:
#	lib/data/dao/player_group_dao.dart
#	test/db_tests/game_test.dart
#	test/db_tests/group_test.dart
#	test/db_tests/player_test.dart
This commit is contained in:
Felix Kirchner
2025-11-21 14:00:10 +01:00
parent 8e63a01705 8c05385203
commit 78d530ddd5
11 changed files with 746 additions and 341 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
lib/data/dao/game_dao.dart
View File

@@ -18,10 +18,8 @@ class GameDao extends DatabaseAccessor<AppDatabase> 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<AppDatabase> with _$GameDaoMixin {
List<Player>? 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(

4
lib/data/dao/group_dao.dart
View File

@@ -16,7 +16,7 @@ class GroupDao extends DatabaseAccessor<AppDatabase> 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<AppDatabase> with _$GroupDaoMixin {
final query = select(groupTable)..where((g) => g.id.equals(groupId));
final result = await query.getSingle();
List<Player> members = await db.playerGroupDao.getPlayersOfGroupById(
List<Player> members = await db.playerGroupDao.getPlayersOfGroup(
groupId: groupId,
);

66
lib/data/dao/group_game_dao.dart
View File

@@ -10,21 +10,18 @@ class GroupGameDao extends DatabaseAccessor<AppDatabase>
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<bool> 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<void> 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<Group?> getGroupByGameId({required String gameId}) async {
Future<Group?> 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<AppDatabase>
return group;
}
/// Associates a group with a game by inserting a record into the
/// [GroupGameTable].
Future<void> 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<bool> 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<bool> 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<bool> 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;
}
}

66
lib/data/dao/player_game_dao.dart
View File

@@ -10,21 +10,21 @@ class PlayerGameDao extends DatabaseAccessor<AppDatabase>
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<bool> 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<void> 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<List<Player>?> getPlayersByGameId({required String gameId}) async {
Future<List<Player>?> 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<AppDatabase>
return players;
}
/// Associates a player with a game by inserting a record into the
/// [PlayerGameTable].
Future<void> addPlayerToGame({
/// Checks if there are any players associated with the given [gameId].
/// Returns `true` if there are players, otherwise `false`.
Future<bool> 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<bool> 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<bool> 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;
}
}

52
lib/data/dao/player_group_dao.dart
View File

@@ -10,8 +10,34 @@ class PlayerGroupDao extends DatabaseAccessor<AppDatabase>
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<bool> 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<List<Player>> getPlayersOfGroupById({required String groupId}) async {
Future<List<Player>> 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<AppDatabase>
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<bool> 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<bool> isPlayerInGroup({

258
test/db_tests/game_test.dart
View File

@@ -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 {});
});
}

134
test/db_tests/group_game_test.dart Normal file
View File

@@ -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);
}
});
});
}

174
test/db_tests/group_test.dart
View File

@@ -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);

140
test/db_tests/player_game_test.dart Normal file
View File

@@ -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);
}
});
});
}

103
test/db_tests/player_group_test.dart Normal file
View File

@@ -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);
}
});
});
}

78
test/db_tests/player_test.dart
View File

@@ -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);