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

MVP #141

Merged
flixcoo merged 705 commits from development into main 2026-01-09 12:55:50 +00:00
Conversation 2 Commits 705 Files Changed 133 +746 -341
11 changed files with 746 additions and 341 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 78d530ddd5 - Show all commits

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

@@ -18,10 +18,8 @@ class GameDao extends DatabaseAccessor<AppDatabase> with _$GameDaoMixin {
return Future.wait( return Future.wait(
result.map((row) async { result.map((row) async {
final group = await db.groupGameDao.getGroupByGameId(gameId: row.id); final group = await db.groupGameDao.getGroupOfGame(gameId: row.id);
final player = await db.playerGameDao.getPlayersByGameId( final player = await db.playerGameDao.getPlayersOfGame(gameId: row.id);
gameId: row.id,
);
return Game( return Game(
id: row.id, id: row.id,
name: row.name, name: row.name,
@@ -41,11 +39,11 @@ class GameDao extends DatabaseAccessor<AppDatabase> with _$GameDaoMixin {
List<Player>? players; List<Player>? players;
if (await db.playerGameDao.gameHasPlayers(gameId: gameId)) { if (await db.playerGameDao.gameHasPlayers(gameId: gameId)) {
players = await db.playerGameDao.getPlayersByGameId(gameId: gameId); players = await db.playerGameDao.getPlayersOfGame(gameId: gameId);
} }
Group? group; Group? group;
if (await db.groupGameDao.hasGameGroup(gameId: gameId)) { if (await db.groupGameDao.gameHasGroup(gameId: gameId)) {
group = await db.groupGameDao.getGroupByGameId(gameId: gameId); group = await db.groupGameDao.getGroupOfGame(gameId: gameId);
} }
return Game( 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(); final result = await query.get();
return Future.wait( return Future.wait(
result.map((groupData) async { result.map((groupData) async {
final members = await db.playerGroupDao.getPlayersOfGroupById( final members = await db.playerGroupDao.getPlayersOfGroup(
groupId: groupData.id, groupId: groupData.id,
); );
return Group( return Group(
@@ -34,7 +34,7 @@ class GroupDao extends DatabaseAccessor<AppDatabase> with _$GroupDaoMixin {
final query = select(groupTable)..where((g) => g.id.equals(groupId)); final query = select(groupTable)..where((g) => g.id.equals(groupId));
final result = await query.getSingle(); final result = await query.getSingle();
List<Player> members = await db.playerGroupDao.getPlayersOfGroupById( List<Player> members = await db.playerGroupDao.getPlayersOfGroup(
groupId: groupId, groupId: groupId,
); );

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

@@ -10,21 +10,18 @@ class GroupGameDao extends DatabaseAccessor<AppDatabase>
with _$GroupGameDaoMixin { with _$GroupGameDaoMixin {
GroupGameDao(super.db); GroupGameDao(super.db);
/// Checks if there is a group associated with the given [gameId]. /// Associates a group with a game by inserting a record into the
/// Returns `true` if there is a group, otherwise `false`. /// [GroupGameTable].
Future<bool> hasGameGroup({required String gameId}) async { Future<void> addGroupToGame(String gameId, String groupId) async {
final count = await into(groupGameTable).insert(
await (selectOnly(groupGameTable) GroupGameTableCompanion.insert(groupId: groupId, gameId: gameId),
..where(groupGameTable.gameId.equals(gameId)) mode: InsertMode.insertOrReplace,
..addColumns([groupGameTable.groupId.count()])) );
.map((row) => row.read(groupGameTable.groupId.count()))
.getSingle();
return (count ?? 0) > 0;
} }
/// Retrieves the [Group] associated with the given [gameId]. /// Retrieves the [Group] associated with the given [gameId].
/// Returns `null` if no group is found. /// 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( final result = await (select(
groupGameTable, groupGameTable,
)..where((g) => g.gameId.equals(gameId))).getSingleOrNull(); )..where((g) => g.gameId.equals(gameId))).getSingleOrNull();
@@ -37,11 +34,46 @@ class GroupGameDao extends DatabaseAccessor<AppDatabase>
return group; return group;
} }
/// Associates a group with a game by inserting a record into the /// Checks if there is a group associated with the given [gameId].
/// [GroupGameTable]. /// Returns `true` if there is a group, otherwise `false`.
Future<void> addGroupToGame(String gameId, String groupId) async { Future<bool> gameHasGroup({required String gameId}) async {
await into( final count =
groupGameTable, await (selectOnly(groupGameTable)
).insert(GroupGameTableCompanion.insert(groupId: groupId, gameId: gameId), mode: InsertMode.insertOrReplace); ..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 { with _$PlayerGameDaoMixin {
PlayerGameDao(super.db); PlayerGameDao(super.db);
/// Checks if there are any players associated with the given [gameId]. /// Associates a player with a game by inserting a record into the
/// Returns `true` if there are players, otherwise `false`. /// [PlayerGameTable].
Future<bool> gameHasPlayers({required String gameId}) async { Future<void> addPlayerToGame({
final count = required String gameId,
await (selectOnly(playerGameTable) required String playerId,
..where(playerGameTable.gameId.equals(gameId)) }) async {
..addColumns([playerGameTable.playerId.count()])) await into(playerGameTable).insert(
.map((row) => row.read(playerGameTable.playerId.count())) PlayerGameTableCompanion.insert(playerId: playerId, gameId: gameId),
.getSingle(); mode: InsertMode.insertOrReplace,
return (count ?? 0) > 0; );
} }
/// Retrieves a list of [Player]s associated with the given [gameId]. /// Retrieves a list of [Player]s associated with the given [gameId].
/// Returns null if no players are found. /// 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( final result = await (select(
playerGameTable, playerGameTable,
)..where((p) => p.gameId.equals(gameId))).get(); )..where((p) => p.gameId.equals(gameId))).get();
@@ -38,15 +38,45 @@ class PlayerGameDao extends DatabaseAccessor<AppDatabase>
return players; return players;
} }
/// Associates a player with a game by inserting a record into the /// Checks if there are any players associated with the given [gameId].
/// [PlayerGameTable]. /// Returns `true` if there are players, otherwise `false`.
Future<void> addPlayerToGame({ 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 gameId,
required String playerId, required String playerId,
}) async { }) async {
await into(playerGameTable).insert( final count =
PlayerGameTableCompanion.insert(playerId: playerId, gameId: gameId), await (selectOnly(playerGameTable)
mode: InsertMode.insertOrReplace, ..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 { with _$PlayerGroupDaoMixin {
PlayerGroupDao(super.db); 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]. /// 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) final query = select(playerGroupTable)
..where((pG) => pG.groupId.equals(groupId)); ..where((pG) => pG.groupId.equals(groupId));
final result = await query.get(); final result = await query.get();
@@ -38,30 +64,6 @@ class PlayerGroupDao extends DatabaseAccessor<AppDatabase>
return rowsAffected > 0; 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]. /// Checks if a player with [playerId] is in the group with [groupId].
/// Returns `true` if the player is in the group, otherwise `false`. /// Returns `true` if the player is in the group, otherwise `false`.
Future<bool> isPlayerInGroup({ 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() { void main() {
late AppDatabase database; late AppDatabase database;
late Player player1; late Player testPlayer1;
late Player player2; late Player testPlayer2;
late Player player3; late Player testPlayer3;
late Player player4; late Player testPlayer4;
late Player player5; late Player testPlayer5;
late Group testgroup; late Group testGroup1;
late Group testgroup2; late Group testGroup2;
late Game testgame; late Game testGame1;
late Game testgame2; late Game testGame2;
late Game testGameOnlyPlayers;
late Game testGameOnlyGroup;
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23); final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
final fakeClock = Clock(() => fixedDate); final fakeClock = Clock(() => fixedDate);
@@ -31,29 +33,34 @@ void main() {
); );
withClock(fakeClock, () { withClock(fakeClock, () {
player1 = Player(name: 'Alice'); testPlayer1 = Player(name: 'Alice');
player2 = Player(name: 'Bob'); testPlayer2 = Player(name: 'Bob');
player3 = Player(name: 'Charlie'); testPlayer3 = Player(name: 'Charlie');
player4 = Player(name: 'Diana'); testPlayer4 = Player(name: 'Diana');
player5 = Player(name: 'Eve'); testPlayer5 = Player(name: 'Eve');
testgroup = Group( testGroup1 = Group(
name: 'Test Group', name: 'Test Group 2',
members: [player1, player2, player3], members: [testPlayer1, testPlayer2, testPlayer3],
); );
testgroup2 = Group( testGroup2 = Group(
name: 'Test Group', name: 'Test Group 2',
members: [player1, player2, player3], members: [testPlayer4, testPlayer5],
); );
testgame = Game( testGame1 = Game(
name: 'Test Game', name: 'First Test Game',
group: testgroup, group: testGroup1,
players: [player4, player5], players: [testPlayer4, testPlayer5],
); );
testgame2 = Game( testGame2 = Game(
name: 'Second Test Game', name: 'Second Test Game',
group: testgroup2, group: testGroup2,
players: [player1, player2, player3], 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 { tearDown(() async {
@@ -62,154 +69,135 @@ void main() {
group('Game Tests', () { group('Game Tests', () {
test('Adding and fetching single game works correclty', () async { 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.id, testGame1.id);
expect(result.name, testgame.name); expect(result.name, testGame1.name);
expect(result.winner, testgame.winner); expect(result.winner, testGame1.winner);
expect(result.createdAt, testgame.createdAt); expect(result.createdAt, testGame1.createdAt);
if (result.group != null) { 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++) { for (int i = 0; i < testGroup1.members.length; i++) {
expect(result.group!.members[i].id, testgroup.members[i].id); expect(result.group!.members[i].id, testGroup1.members[i].id);
expect(result.group!.members[i].name, testgroup.members[i].name); expect(result.group!.members[i].name, testGroup1.members[i].name);
} }
} else { } else {
fail('Group is null'); fail('Group is null');
} }
if (result.players != 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++) { for (int i = 0; i < testGame1.players!.length; i++) {
expect(result.players![i].id, testgame.players![i].id); expect(result.players![i].id, testGame1.players![i].id);
expect(result.players![i].name, testgame.players![i].name); expect(result.players![i].name, testGame1.players![i].name);
expect(result.players![i].createdAt, testgame.players![i].createdAt); expect(result.players![i].createdAt, testGame1.players![i].createdAt);
} }
} else { } else {
fail('Players is null'); fail('Players is null');
} }
}); });
test('Adding and fetching multiple games works correclty', () async { test('Adding and fetching multiple games works correctly', () async {
await database.gameDao.addGames(games: [testgame, testgame2]); // 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(); final allGames = await database.gameDao.getAllGames();
expect(allGames.length, 2); expect(allGames.length, 4);
final fetchedGame1 = allGames.firstWhere((g) => g.id == testgame.id); final testGames = {
// game checks testGame1.id: testGame1,
expect(fetchedGame1.id, testgame.id); testGame2.id: testGame2,
expect(fetchedGame1.name, testgame.name); testGameOnlyGroup.id: testGameOnlyGroup,
expect(fetchedGame1.createdAt, testgame.createdAt); testGameOnlyPlayers.id: testGameOnlyPlayers,
expect(fetchedGame1.winner, testgame.winner); };
// group checks for (final game in allGames) {
expect(fetchedGame1.group!.id, testgame.group!.id); final expectedGame = testGames[game.id]!;
expect(fetchedGame1.group!.name, testgame.group!.name);
expect(fetchedGame1.group!.createdAt, testgame.group!.createdAt);
// group members checks
expect(
fetchedGame1.group!.members.length,
testgame.group!.members.length,
);
for (int i = 0; i < testgame.group!.members.length; i++) {
expect(
fetchedGame1.group!.members[i].id,
testgame.group!.members[i].id,
);
expect(
fetchedGame1.group!.members[i].name,
testgame.group!.members[i].name,
);
expect(
fetchedGame1.group!.members[i].createdAt,
testgame.group!.members[i].createdAt,
);
}
// players checks // Game-Checks
for (int i = 0; i < fetchedGame1.players!.length; i++) { expect(game.id, expectedGame.id);
expect(fetchedGame1.players![i].id, testgame.players![i].id); expect(game.name, expectedGame.name);
expect(fetchedGame1.players![i].name, testgame.players![i].name); expect(game.createdAt, expectedGame.createdAt);
expect( expect(game.winner, expectedGame.winner);
fetchedGame1.players![i].createdAt,
testgame.players![i].createdAt,
);
}
final fetchedGame2 = allGames.firstWhere((g) => g.id == testgame2.id); // Group-Checks
// game checks if (expectedGame.group != null) {
expect(fetchedGame2.id, testgame2.id); expect(game.group!.id, expectedGame.group!.id);
expect(fetchedGame2.name, testgame2.name); expect(game.group!.name, expectedGame.group!.name);
expect(fetchedGame2.createdAt, testgame2.createdAt); expect(game.group!.createdAt, expectedGame.group!.createdAt);
expect(fetchedGame2.winner, testgame2.winner);
// group checks // Group Members-Checks
expect(fetchedGame2.group!.id, testgame2.group!.id); expect(
expect(fetchedGame2.group!.name, testgame2.group!.name); game.group!.members.length,
expect(fetchedGame2.group!.createdAt, testgame2.group!.createdAt); expectedGame.group!.members.length,
// group members checks );
expect( for (int i = 0; i < expectedGame.group!.members.length; i++) {
fetchedGame2.group!.members.length, expect(
testgame2.group!.members.length, game.group!.members[i].id,
); expectedGame.group!.members[i].id,
for (int i = 0; i < testgame2.group!.members.length; i++) { );
expect( expect(
fetchedGame2.group!.members[i].id, game.group!.members[i].name,
testgame2.group!.members[i].id, expectedGame.group!.members[i].name,
); );
expect( expect(
fetchedGame2.group!.members[i].name, game.group!.members[i].createdAt,
testgame2.group!.members[i].name, expectedGame.group!.members[i].createdAt,
); );
expect( }
fetchedGame2.group!.members[i].createdAt, }
testgame2.group!.members[i].createdAt,
);
}
// players checks // Players-Checks
for (int i = 0; i < fetchedGame2.players!.length; i++) { if (expectedGame.players != null) {
expect(fetchedGame2.players![i].id, testgame2.players![i].id); expect(game.players!.length, expectedGame.players!.length);
expect(fetchedGame2.players![i].name, testgame2.players![i].name); for (int i = 0; i < expectedGame.players!.length; i++) {
expect( expect(game.players![i].id, expectedGame.players![i].id);
fetchedGame2.players![i].createdAt, expect(game.players![i].name, expectedGame.players![i].name);
testgame2.players![i].createdAt, expect(
); game.players![i].createdAt,
expectedGame.players![i].createdAt,
);
}
}
} }
}); });
test('Adding the same game twice does not create duplicates', () async { test('Adding the same game twice does not create duplicates', () async {
await database.gameDao.addGame(game: testgame); await database.gameDao.addGame(game: testGame1);
await database.gameDao.addGame(game: testgame); await database.gameDao.addGame(game: testGame1);
final gameCount = await database.gameDao.getGameCount(); final gameCount = await database.gameDao.getGameCount();
expect(gameCount, 1); expect(gameCount, 1);
}); });
test('Game existence check works correctly', () async { 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); 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); expect(gameExists, true);
}); });
test('Deleting a game works correclty', () async { 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( final gameDeleted = await database.gameDao.deleteGame(
gameId: testgame.id, gameId: testGame1.id,
); );
expect(gameDeleted, true); expect(gameDeleted, true);
final gameExists = await database.gameDao.gameExists(gameId: testgame.id); final gameExists = await database.gameDao.gameExists(
gameId: testGame1.id,
);
expect(gameExists, false); expect(gameExists, false);
}); });
@@ -217,31 +205,25 @@ void main() {
var gameCount = await database.gameDao.getGameCount(); var gameCount = await database.gameDao.getGameCount();
expect(gameCount, 0); expect(gameCount, 0);
await database.gameDao.addGame(game: testgame); await database.gameDao.addGame(game: testGame1);
gameCount = await database.gameDao.getGameCount(); gameCount = await database.gameDao.getGameCount();
expect(gameCount, 1); expect(gameCount, 1);
await database.gameDao.addGame(game: testgame2); await database.gameDao.addGame(game: testGame2);
gameCount = await database.gameDao.getGameCount(); gameCount = await database.gameDao.getGameCount();
expect(gameCount, 2); expect(gameCount, 2);
await database.gameDao.deleteGame(gameId: testgame.id); await database.gameDao.deleteGame(gameId: testGame1.id);
gameCount = await database.gameDao.getGameCount(); gameCount = await database.gameDao.getGameCount();
expect(gameCount, 1); expect(gameCount, 1);
await database.gameDao.deleteGame(gameId: testgame2.id); await database.gameDao.deleteGame(gameId: testGame2.id);
gameCount = await database.gameDao.getGameCount(); gameCount = await database.gameDao.getGameCount();
expect(gameCount, 0); 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() { void main() {
late AppDatabase database; late AppDatabase database;
late Player player1; late Player testPlayer1;
late Player player2; late Player testPlayer2;
late Player player3; late Player testPlayer3;
late Player player4; late Player testPlayer4;
late Group testgroup; late Group testGroup1;
late Group testgroup2; late Group testGroup2;
late Group testGroup3;
late Group testGroup4;
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23); final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
final fakeClock = Clock(() => fixedDate); final fakeClock = Clock(() => fixedDate);
@@ -27,18 +29,28 @@ void main() {
); );
withClock(fakeClock, () { withClock(fakeClock, () {
player1 = Player(name: 'Alice'); testPlayer1 = Player(name: 'Alice');
player2 = Player(name: 'Bob'); testPlayer2 = Player(name: 'Bob');
player3 = Player(name: 'Charlie'); testPlayer3 = Player(name: 'Charlie');
player4 = Player(name: 'Diana'); testPlayer4 = Player(name: 'Diana');
testgroup = Group( testGroup1 = Group(
name: 'Test Group', name: 'Test Group',
members: [player1, player2, player3], members: [testPlayer1, testPlayer2, testPlayer3],
); );
testgroup2 = Group( testGroup2 = Group(
id: 'gr2', id: 'gr2',
name: 'Second Group', 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', () { group('Group Tests', () {
test('Adding and fetching a single group works correctly', () async { 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( final fetchedGroup = await database.groupDao.getGroupById(
groupId: testgroup.id, groupId: testGroup1.id,
); );
expect(fetchedGroup.id, testgroup.id); expect(fetchedGroup.id, testGroup1.id);
expect(fetchedGroup.name, testgroup.name); expect(fetchedGroup.name, testGroup1.name);
expect(fetchedGroup.createdAt, testgroup.createdAt); expect(fetchedGroup.createdAt, testGroup1.createdAt);
expect(fetchedGroup.members.length, testgroup.members.length); expect(fetchedGroup.members.length, testGroup1.members.length);
for (int i = 0; i < testgroup.members.length; i++) { for (int i = 0; i < testGroup1.members.length; i++) {
expect(fetchedGroup.members[i].id, testgroup.members[i].id); expect(fetchedGroup.members[i].id, testGroup1.members[i].id);
expect(fetchedGroup.members[i].name, testgroup.members[i].name); expect(fetchedGroup.members[i].name, testGroup1.members[i].name);
expect( expect(
fetchedGroup.members[i].createdAt, fetchedGroup.members[i].createdAt,
testgroup.members[i].createdAt, testGroup1.members[i].createdAt,
); );
} }
}); });
test('Adding and fetching a single group works correctly', () async { test('Adding and fetching multiple groups works correctly', () async {
await database.groupDao.addGroups(groups: [testgroup, testgroup2]); // 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(); final allGroups = await database.groupDao.getAllGroups();
expect(allGroups.length, 2); expect(allGroups.length, 2);
final fetchedGroup1 = allGroups.firstWhere((g) => g.id == testgroup.id); final testGroups = {testGroup1.id: testGroup1, testGroup2.id: testGroup2};
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 fetchedGroup2 = allGroups.firstWhere((g) => g.id == testgroup2.id); for (final group in allGroups) {
expect(fetchedGroup2.name, testgroup2.name); final expectedGroup = testGroups[group.id]!;
expect(fetchedGroup2.members.length, testgroup2.members.length);
expect(fetchedGroup2.members.elementAt(0).id, player2.id); expect(group.id, expectedGroup.id);
expect(fetchedGroup2.members.elementAt(0).createdAt, player2.createdAt); 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 { test('Adding the same group twice does not create duplicates', () async {
await database.groupDao.addGroup(group: testgroup); await database.groupDao.addGroup(group: testGroup1);
await database.groupDao.addGroup(group: testgroup); await database.groupDao.addGroup(group: testGroup1);
final allGroups = await database.groupDao.getAllGroups(); final allGroups = await database.groupDao.getAllGroups();
expect(allGroups.length, 1); expect(allGroups.length, 1);
@@ -97,109 +121,57 @@ void main() {
test('Group existence check works correctly', () async { test('Group existence check works correctly', () async {
var groupExists = await database.groupDao.groupExists( var groupExists = await database.groupDao.groupExists(
groupId: testgroup.id, groupId: testGroup1.id,
); );
expect(groupExists, false); 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); expect(groupExists, true);
}); });
test('Deleting a group works correclty', () async { 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( final groupDeleted = await database.groupDao.deleteGroup(
groupId: testgroup.id, groupId: testGroup1.id,
); );
expect(groupDeleted, true); expect(groupDeleted, true);
final groupExists = await database.groupDao.groupExists( final groupExists = await database.groupDao.groupExists(
groupId: testgroup.id, groupId: testGroup1.id,
); );
expect(groupExists, false); expect(groupExists, false);
}); });
test('Updating a group name works correcly', () async { 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'; const newGroupName = 'new group name';
await database.groupDao.updateGroupname( await database.groupDao.updateGroupname(
groupId: testgroup.id, groupId: testGroup1.id,
newName: newGroupName, newName: newGroupName,
); );
final result = await database.groupDao.getGroupById( final result = await database.groupDao.getGroupById(
groupId: testgroup.id, groupId: testGroup1.id,
); );
expect(result.name, newGroupName); 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 { test('Getting the group count works correctly', () async {
final initialCount = await database.groupDao.getGroupCount(); final initialCount = await database.groupDao.getGroupCount();
expect(initialCount, 0); expect(initialCount, 0);
await database.groupDao.addGroup(group: testgroup); await database.groupDao.addGroup(group: testGroup1);
final groupAdded = await database.groupDao.getGroupCount(); final groupAdded = await database.groupDao.getGroupCount();
expect(groupAdded, 1); expect(groupAdded, 1);
final groupRemoved = await database.groupDao.deleteGroup( final groupRemoved = await database.groupDao.deleteGroup(
groupId: testgroup.id, groupId: testGroup1.id,
); );
expect(groupRemoved, true); 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() { void main() {
late AppDatabase database; late AppDatabase database;
late Player testPlayer; late Player testPlayer1;
late Player testPlayer2; late Player testPlayer2;
late Player testPlayer3;
late Player testPlayer4;
final fixedDate = DateTime(2025, 19, 11, 00, 11, 23); final fixedDate = DateTime(2025, 19, 11, 00, 11, 23);
final fakeClock = Clock(() => fixedDate); final fakeClock = Clock(() => fixedDate);
@@ -22,27 +24,29 @@ void main() {
); );
withClock(fakeClock, () { withClock(fakeClock, () {
testPlayer = Player(name: 'Test Player'); testPlayer1 = Player(name: 'Test Player');
testPlayer2 = Player(name: 'Second Group'); testPlayer2 = Player(name: 'Second Player');
testPlayer3 = Player(name: 'Charlie');
testPlayer4 = Player(name: 'Diana');
}); });
}); });
tearDown(() async { tearDown(() async {
await database.close(); await database.close();
}); });
group('player tests', () { group('Player Tests', () {
test('Adding and fetching single player works correclty', () async { 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); await database.playerDao.addPlayer(player: testPlayer2);
final allPlayers = await database.playerDao.getAllPlayers(); final allPlayers = await database.playerDao.getAllPlayers();
expect(allPlayers.length, 2); expect(allPlayers.length, 2);
final fetchedPlayer1 = allPlayers.firstWhere( final fetchedPlayer1 = allPlayers.firstWhere(
(g) => g.id == testPlayer.id, (g) => g.id == testPlayer1.id,
); );
expect(fetchedPlayer1.name, testPlayer.name); expect(fetchedPlayer1.name, testPlayer1.name);
expect(fetchedPlayer1.createdAt, testPlayer.createdAt); expect(fetchedPlayer1.createdAt, testPlayer1.createdAt);
final fetchedPlayer2 = allPlayers.firstWhere( final fetchedPlayer2 = allPlayers.firstWhere(
(g) => g.id == testPlayer2.id, (g) => g.id == testPlayer2.id,
@@ -52,27 +56,35 @@ void main() {
}); });
test('Adding and fetching multiple players works correclty', () async { 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(); final allPlayers = await database.playerDao.getAllPlayers();
expect(allPlayers.length, 2); expect(allPlayers.length, 4);
final fetchedPlayer1 = allPlayers.firstWhere( // Map for connencting fetched players with expected players
(g) => g.id == testPlayer.id, final testPlayer = {
); testPlayer1.id: testPlayer1,
expect(fetchedPlayer1.name, testPlayer.name); testPlayer2.id: testPlayer2,
expect(fetchedPlayer1.createdAt, testPlayer.createdAt); testPlayer3.id: testPlayer3,
testPlayer4.id: testPlayer4,
};
final fetchedPlayer2 = allPlayers.firstWhere( for (final player in allPlayers) {
(g) => g.id == testPlayer2.id, final expectedPlayer = testPlayer[player.id]!;
);
expect(fetchedPlayer2.name, testPlayer2.name); expect(player.id, expectedPlayer.id);
expect(fetchedPlayer2.createdAt, testPlayer2.createdAt); expect(player.name, expectedPlayer.name);
expect(player.createdAt, expectedPlayer.createdAt);
}
}); });
test('Adding the same player twice does not create duplicates', () async { test('Adding the same player twice does not create duplicates', () async {
await database.playerDao.addPlayer(player: testPlayer); await database.playerDao.addPlayer(player: testPlayer1);
await database.playerDao.addPlayer(player: testPlayer); await database.playerDao.addPlayer(player: testPlayer1);
final allPlayers = await database.playerDao.getAllPlayers(); final allPlayers = await database.playerDao.getAllPlayers();
expect(allPlayers.length, 1); expect(allPlayers.length, 1);
@@ -80,43 +92,43 @@ void main() {
test('Player existence check works correctly', () async { test('Player existence check works correctly', () async {
var playerExists = await database.playerDao.playerExists( var playerExists = await database.playerDao.playerExists(
playerId: testPlayer.id, playerId: testPlayer1.id,
); );
expect(playerExists, false); expect(playerExists, false);
await database.playerDao.addPlayer(player: testPlayer); await database.playerDao.addPlayer(player: testPlayer1);
playerExists = await database.playerDao.playerExists( playerExists = await database.playerDao.playerExists(
playerId: testPlayer.id, playerId: testPlayer1.id,
); );
expect(playerExists, true); expect(playerExists, true);
}); });
test('Deleting a player works correclty', () async { 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( final playerDeleted = await database.playerDao.deletePlayer(
playerId: testPlayer.id, playerId: testPlayer1.id,
); );
expect(playerDeleted, true); expect(playerDeleted, true);
final playerExists = await database.playerDao.playerExists( final playerExists = await database.playerDao.playerExists(
playerId: testPlayer.id, playerId: testPlayer1.id,
); );
expect(playerExists, false); expect(playerExists, false);
}); });
test('Updating a player name works correcly', () async { 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'; const newPlayerName = 'new player name';
await database.playerDao.updatePlayername( await database.playerDao.updatePlayername(
playerId: testPlayer.id, playerId: testPlayer1.id,
newName: newPlayerName, newName: newPlayerName,
); );
final result = await database.playerDao.getPlayerById( final result = await database.playerDao.getPlayerById(
playerId: testPlayer.id, playerId: testPlayer1.id,
); );
expect(result.name, newPlayerName); expect(result.name, newPlayerName);
}); });
@@ -125,7 +137,7 @@ void main() {
var playerCount = await database.playerDao.getPlayerCount(); var playerCount = await database.playerDao.getPlayerCount();
expect(playerCount, 0); expect(playerCount, 0);
await database.playerDao.addPlayer(player: testPlayer); await database.playerDao.addPlayer(player: testPlayer1);
playerCount = await database.playerDao.getPlayerCount(); playerCount = await database.playerDao.getPlayerCount();
expect(playerCount, 1); expect(playerCount, 1);
@@ -135,7 +147,7 @@ void main() {
playerCount = await database.playerDao.getPlayerCount(); playerCount = await database.playerDao.getPlayerCount();
expect(playerCount, 2); expect(playerCount, 2);
await database.playerDao.deletePlayer(playerId: testPlayer.id); await database.playerDao.deletePlayer(playerId: testPlayer1.id);
playerCount = await database.playerDao.getPlayerCount(); playerCount = await database.playerDao.getPlayerCount();
expect(playerCount, 1); expect(playerCount, 1);