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

Merge pull request 'Datenbankkorrekturen' (#25) from enhancement/24-datenbankkorrekturen into development

Browse Source 
Reviewed-on: #25
Reviewed-by: mathiskir <mathis.kirchner.mk@gmail.com>
This commit was merged in pull request #25.
This commit is contained in:
Felix Kirchner
2025-11-16 20:57:40 +00:00
parent 06933a67ac 630836d40c
commit 729cd5eff1
4 changed files with 159 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -38,28 +38,32 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
/// Adds a new group with the given [id] and [name] to the database. /// Adds a new group with the given [id] and [name] to the database.
/// This method also adds the group's members to the [PlayerGroupTable]. /// This method also adds the group's members to the [PlayerGroupTable].
Future<void> addGroup({required Group group}) async { Future<bool> addGroup({required Group group}) async {
await db.transaction(() async { if (!await groupExists(groupId: group.id)) {
await into( await db.transaction(() async {
groupTable, await into(
).insert(GroupTableCompanion.insert(id: group.id, name: group.name)); groupTable,
await db.batch( ).insert(GroupTableCompanion.insert(id: group.id, name: group.name));
(b) => b.insertAll( await db.batch(
db.playerGroupTable, (b) => b.insertAll(
group.members db.playerGroupTable,
.map( group.members
(member) => PlayerGroupTableCompanion.insert( .map(
playerId: member.id, (member) => PlayerGroupTableCompanion.insert(
groupId: group.id, playerId: member.id,
), groupId: group.id,
) ),
.toList(), )
), .toList(),
); ),
await Future.wait( );
group.members.map((player) => db.playerDao.addPlayer(player: player)), await Future.wait(
); group.members.map((player) => db.playerDao.addPlayer(player: player)),
}); );
return true;
});
}
return false;
} }
/// Deletes the group with the given [id] from the database. /// Deletes the group with the given [id] from the database.

6
lib/data/dao/player_dao.dart
View File

@@ -26,14 +26,14 @@ class PlayerDao extends DatabaseAccessor<AppDatabase> with _$PlayerDaoMixin {
/// Adds a new [player] to the database. /// Adds a new [player] to the database.
/// If a player with the same ID already exists, updates their name to /// If a player with the same ID already exists, updates their name to
/// the new one. /// the new one.
Future<void> addPlayer({required Player player}) async { Future<bool> addPlayer({required Player player}) async {
if (!await playerExists(playerId: player.id)) { if (!await playerExists(playerId: player.id)) {
await into( await into(
playerTable, playerTable,
).insert(PlayerTableCompanion.insert(id: player.id, name: player.name)); ).insert(PlayerTableCompanion.insert(id: player.id, name: player.name));
} else { return true;
await updatePlayername(playerId: player.id, newName: player.name);
} }
return false;
} }
/// Deletes the player with the given [id] from the database. /// Deletes the player with the given [id] from the database.

191
test/db_tests/group_test.dart
View File

@@ -35,115 +35,146 @@ void main() {
tearDown(() async { tearDown(() async {
await database.close(); await database.close();
}); });
group('group tests', () {
test('all groups get fetched correctly', () async {
final testgroup2 = Group(
id: 'gr2',
name: 'Second Group',
members: [player2, player3, player4],
);
await database.groupDao.addGroup(group: testgroup);
await database.groupDao.addGroup(group: testgroup2);
//TODO: test getAllGroups method final allGroups = await database.groupDao.getAllGroups();
test('group and group members gets added correctly', () async { expect(allGroups.length, 2);
await database.groupDao.addGroup(group: testgroup);
final result = await database.groupDao.getGroupById(groupId: testgroup.id); 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(result.id, testgroup.id); final fetchedGroup2 = allGroups.firstWhere((g) => g.id == testgroup2.id);
expect(result.name, testgroup.name); expect(fetchedGroup2.name, testgroup2.name);
expect(fetchedGroup2.members.length, testgroup2.members.length);
expect(fetchedGroup2.members.elementAt(0).id, player2.id);
});
expect(result.members.length, testgroup.members.length); test('group and group members gets added correctly', () async {
for (int i = 0; i < testgroup.members.length; i++) { await database.groupDao.addGroup(group: testgroup);
expect(result.members[i].id, testgroup.members[i].id);
expect(result.members[i].name, testgroup.members[i].name);
}
});
test('group gets deleted correctly', () async { final result = await database.groupDao.getGroupById(
await database.groupDao.addGroup(group: testgroup); groupId: testgroup.id,
);
final groupDeleted = await database.groupDao.deleteGroup( expect(result.id, testgroup.id);
groupId: testgroup.id, expect(result.name, testgroup.name);
);
expect(groupDeleted, true);
final groupExists = await database.groupDao.groupExists( expect(result.members.length, testgroup.members.length);
groupId: testgroup.id, for (int i = 0; i < testgroup.members.length; i++) {
); expect(result.members[i].id, testgroup.members[i].id);
expect(groupExists, false); expect(result.members[i].name, testgroup.members[i].name);
}); }
});
test('group name gets updated correcly ', () async { test('group gets deleted correctly', () async {
await database.groupDao.addGroup(group: testgroup); await database.groupDao.addGroup(group: testgroup);
const newGroupName = 'new group name'; final groupDeleted = await database.groupDao.deleteGroup(
groupId: testgroup.id,
);
expect(groupDeleted, true);
await database.groupDao.updateGroupname( final groupExists = await database.groupDao.groupExists(
groupId: testgroup.id, groupId: testgroup.id,
newName: newGroupName, );
); expect(groupExists, false);
});
final result = await database.groupDao.getGroupById(groupId: testgroup.id); test('group name gets updated correcly ', () async {
expect(result.name, newGroupName); await database.groupDao.addGroup(group: testgroup);
});
test('Adding player to group works correctly', () async { const newGroupName = 'new group name';
await database.groupDao.addGroup(group: testgroup);
await database.playerGroupDao.addPlayerToGroup( await database.groupDao.updateGroupname(
player: player4, groupId: testgroup.id,
groupId: testgroup.id, newName: newGroupName,
); );
final playerAdded = await database.playerGroupDao.isPlayerInGroup( final result = await database.groupDao.getGroupById(
playerId: player4.id, groupId: testgroup.id,
groupId: testgroup.id, );
); expect(result.name, newGroupName);
});
expect(playerAdded, true); test('Adding player to group works correctly', () async {
await database.groupDao.addGroup(group: testgroup);
final playerAdded2 = await database.playerGroupDao.isPlayerInGroup( await database.playerGroupDao.addPlayerToGroup(
playerId: 'a', player: player4,
groupId: testgroup.id, groupId: testgroup.id,
); );
expect(playerAdded2, false); final playerAdded = await database.playerGroupDao.isPlayerInGroup(
playerId: player4.id,
groupId: testgroup.id,
);
expect(playerAdded, true); expect(playerAdded, true);
final result = await database.groupDao.getGroupById(groupId: testgroup.id); final playerAdded2 = await database.playerGroupDao.isPlayerInGroup(
expect(result.members.length, testgroup.members.length + 1); playerId: 'a',
groupId: testgroup.id,
);
final addedPlayer = result.members.firstWhere((p) => p.id == player4.id); expect(playerAdded2, false);
expect(addedPlayer.name, player4.name);
});
test('Removing player from group works correctly', () async { expect(playerAdded, true);
await database.groupDao.addGroup(group: testgroup);
final playerToRemove = testgroup.members[0]; final result = await database.groupDao.getGroupById(
groupId: testgroup.id,
);
expect(result.members.length, testgroup.members.length + 1);
final removed = await database.playerGroupDao.removePlayerFromGroup( final addedPlayer = result.members.firstWhere((p) => p.id == player4.id);
playerId: playerToRemove.id, expect(addedPlayer.name, player4.name);
groupId: testgroup.id, });
);
expect(removed, true);
final result = await database.groupDao.getGroupById(groupId: testgroup.id); test('Removing player from group works correctly', () async {
expect(result.members.length, testgroup.members.length - 1); await database.groupDao.addGroup(group: testgroup);
final playerExists = result.members.any((p) => p.id == playerToRemove.id); final playerToRemove = testgroup.members[0];
expect(playerExists, false);
});
test('get group count works correctly', () async { final removed = await database.playerGroupDao.removePlayerFromGroup(
final initialCount = await database.groupDao.getGroupCount(); playerId: playerToRemove.id,
expect(initialCount, 0); groupId: testgroup.id,
);
expect(removed, true);
await database.groupDao.addGroup(group: testgroup); final result = await database.groupDao.getGroupById(
groupId: testgroup.id,
);
expect(result.members.length, testgroup.members.length - 1);
final groupAdded = await database.groupDao.getGroupCount(); final playerExists = result.members.any((p) => p.id == playerToRemove.id);
expect(groupAdded, 1); expect(playerExists, false);
});
final groupRemoved = await database.groupDao.deleteGroup( test('get group count works correctly', () async {
groupId: testgroup.id, final initialCount = await database.groupDao.getGroupCount();
); expect(initialCount, 0);
expect(groupRemoved, true);
final finalCount = await database.groupDao.getGroupCount(); await database.groupDao.addGroup(group: testgroup);
expect(finalCount, 0);
final groupAdded = await database.groupDao.getGroupCount();
expect(groupAdded, 1);
final groupRemoved = await database.groupDao.deleteGroup(
groupId: testgroup.id,
);
expect(groupRemoved, true);
final finalCount = await database.groupDao.getGroupCount();
expect(finalCount, 0);
});
}); });
} }

19
test/db_tests/player_test.dart
View File

@@ -24,6 +24,25 @@ void main() {
}); });
group('player tests', () { group('player tests', () {
test('all players get fetched correctly', () async {
final testPlayer2 = Player(id: 'gr2', name: 'Second Group');
await database.playerDao.addPlayer(player: testPlayer);
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,
);
expect(fetchedPlayer1.name, testPlayer.name);
final fetchedPlayer2 = allPlayers.firstWhere(
(g) => g.id == testPlayer2.id,
);
expect(fetchedPlayer2.name, testPlayer2.name);
});
test('players get inserted correcly ', () async { test('players get inserted correcly ', () async {
await database.playerDao.addPlayer(player: testPlayer); await database.playerDao.addPlayer(player: testPlayer);
final result = await database.playerDao.getPlayerById( final result = await database.playerDao.getPlayerById(