Fixed test issues

test/db_tests/aggregates/group_test.dart

@@ -99,10 +99,10 @@ void main() {
 
       test('addGroup() returns false when group already exists', () async {
         final firstAdd = await database.groupDao.addGroup(group: testGroup1);
-        expect(firstAdd, true);
+        expect(firstAdd, isTrue);
 
         final secondAdd = await database.groupDao.addGroup(group: testGroup1);
-        expect(secondAdd, false);
+        expect(secondAdd, isFalse);
 
         final allGroups = await database.groupDao.getAllGroups();
         expect(allGroups.length, 1);
@@ -150,14 +150,14 @@ void main() {
         var groupExists = await database.groupDao.groupExists(
           groupId: testGroup1.id,
         );
-        expect(groupExists, false);
+        expect(groupExists, isFalse);
 
         await database.groupDao.addGroup(group: testGroup1);
 
         groupExists = await database.groupDao.groupExists(
           groupId: testGroup1.id,
         );
-        expect(groupExists, true);
+        expect(groupExists, isTrue);
       });
 
       test('getGroupCount() works correctly', () async {
@@ -165,19 +165,19 @@ void main() {
         expect(count, 0);
 
         var added = await database.groupDao.addGroup(group: testGroup1);
-        expect(added, true);
+        expect(added, isTrue);
         count = await database.groupDao.getGroupCount();
         expect(count, 1);
 
         added = await database.groupDao.addGroup(group: testGroup2);
-        expect(added, true);
+        expect(added, isTrue);
         count = await database.groupDao.getGroupCount();
         expect(count, 2);
 
         final removed = await database.groupDao.deleteGroup(
           groupId: testGroup1.id,
         );
-        expect(removed, true);
+        expect(removed, isTrue);
         count = await database.groupDao.getGroupCount();
         expect(count, 1);
       });
@@ -225,7 +225,7 @@ void main() {
           groupId: 'non-existent-id',
           newName: 'New name',
         );
-        expect(updated, false);
+        expect(updated, isFalse);
       });
 
       test('updateGroupDescription() works correctly', () async {
@@ -236,7 +236,7 @@ void main() {
           groupId: testGroup1.id,
           newDescription: newDescription,
         );
-        expect(updated, true);
+        expect(updated, isTrue);
 
         final group = await database.groupDao.getGroupById(
           groupId: testGroup1.id,
@@ -251,7 +251,7 @@ void main() {
             groupId: 'non-existent-id',
             newDescription: 'New description',
           );
-          expect(updated, false);
+          expect(updated, isFalse);
         },
       );
 
@@ -288,21 +288,21 @@ void main() {
               .map((p) => p.id)
               .toList()
               .contains(testPlayer1.id),
-          true,
+          isTrue,
         );
         expect(
           initialGroup.members
               .map((p) => p.id)
               .toList()
               .contains(testPlayer2.id),
-          true,
+          isTrue,
         );
         expect(
           initialGroup.members
               .map((p) => p.id)
               .toList()
               .contains(testPlayer3.id),
-          true,
+          isTrue,
         );
 
         final newPlayers = [testPlayer2, testPlayer4];
@@ -310,7 +310,7 @@ void main() {
           groupId: testGroup1.id,
           newPlayers: newPlayers,
         );
-        expect(replaced, true);
+        expect(replaced, isTrue);
 
         final updatedGroup = await database.groupDao.getGroupById(
           groupId: testGroup1.id,
@@ -318,31 +318,25 @@ void main() {
         expect(updatedGroup.members.length, 2);
 
         final memberIds = updatedGroup.members.map((p) => p.id).toList();
-        expect(memberIds.contains(testPlayer2.id), true);
+        expect(memberIds.contains(testPlayer2.id), isTrue);
-        expect(memberIds.contains(testPlayer4.id), true);
+        expect(memberIds.contains(testPlayer4.id), isTrue);
-        expect(memberIds.contains(testPlayer1.id), false);
+        expect(memberIds.contains(testPlayer1.id), isFalse);
-        expect(memberIds.contains(testPlayer3.id), false);
+        expect(memberIds.contains(testPlayer3.id), isFalse);
       });
 
-      test('replaceGroupPlayers() with empty list works correctly', () async {
+      test('replaceGroupPlayers() ignores empty list ', () async {
         await database.groupDao.addGroup(group: testGroup1);
 
-        final initialGroup = await database.groupDao.getGroupById(
-          groupId: testGroup1.id,
-        );
-        expect(initialGroup.members.length, 3);
-
         final replaced = await database.playerGroupDao.replaceGroupPlayers(
           groupId: testGroup1.id,
           newPlayers: [],
         );
-        expect(replaced, true);
+        expect(replaced, isFalse);
 
         final updatedGroup = await database.groupDao.getGroupById(
           groupId: testGroup1.id,
         );
-        expect(updatedGroup.members.length, 0);
+        expect(updatedGroup.members.length, testGroup1.members.length);
-        expect(updatedGroup.members, isEmpty);
       });
 
       test(
@@ -352,7 +346,7 @@ void main() {
             groupId: 'non-existent-id',
             newPlayers: [testPlayer1],
           );
-          expect(replaced, false);
+          expect(replaced, isFalse);
         },
       );
     });
@@ -364,19 +358,19 @@ void main() {
         final groupDeleted = await database.groupDao.deleteGroup(
           groupId: testGroup1.id,
         );
-        expect(groupDeleted, true);
+        expect(groupDeleted, isTrue);
 
         final groupExists = await database.groupDao.groupExists(
           groupId: testGroup1.id,
         );
-        expect(groupExists, false);
+        expect(groupExists, isFalse);
       });
 
       test('deleteGroup() returns false for non-existent group', () async {
         final deleted = await database.groupDao.deleteGroup(
           groupId: 'non-existent-id',
         );
-        expect(deleted, false);
+        expect(deleted, isFalse);
       });
 
       test('deleteAllGroups() works correctly', () async {
@@ -388,7 +382,7 @@ void main() {
         expect(count, 2);
 
         final deleted = await database.groupDao.deleteAllGroups();
-        expect(deleted, true);
+        expect(deleted, isTrue);
 
         count = await database.groupDao.getGroupCount();
         expect(count, 0);
@@ -396,7 +390,7 @@ void main() {
 
       test('deleteAllGroups() returns false when no groups exist', () async {
         final deleted = await database.groupDao.deleteAllGroups();
-        expect(deleted, false);
+        expect(deleted, isFalse);
       });
     });
 

test/db_tests/entities/game_test.dart

@@ -58,7 +58,7 @@ void main() {
     group('CREATE', () {
       test('Adding and fetching a single game works correctly', () async {
         final added = await database.gameDao.addGame(game: testGame1);
-        expect(added, true);
+        expect(added, isTrue);
 
         final game = await database.gameDao.getGameById(gameId: testGame1.id);
         expect(game.id, testGame1.id);
@@ -74,7 +74,7 @@ void main() {
         final added = await database.gameDao.addGamesAsList(
           games: [testGame1, testGame2, testGame3],
         );
-        expect(added, true);
+        expect(added, isTrue);
 
         final allGames = await database.gameDao.getAllGames();
         expect(allGames.length, 3);
@@ -101,7 +101,7 @@ void main() {
 
       test('addGamesAsList() returns false for empty list', () async {
         final result = await database.gameDao.addGamesAsList(games: []);
-        expect(result, false);
+        expect(result, isFalse);
 
         final allGames = await database.gameDao.getAllGames();
         expect(allGames.length, 0);
@@ -111,7 +111,7 @@ void main() {
         final added = await database.gameDao.addGamesAsList(
           games: [testGame1, testGame2, testGame1],
         );
-        expect(added, true);
+        expect(added, isTrue);
 
         final allGames = await database.gameDao.getAllGames();
         expect(allGames.length, 2);
@@ -160,11 +160,11 @@ void main() {
 
       test('gameExists() works correctly', () async {
         var exists = await database.gameDao.gameExists(gameId: testGame1.id);
-        expect(exists, false);
+        expect(exists, isFalse);
 
         await database.gameDao.addGame(game: testGame1);
         exists = await database.gameDao.gameExists(gameId: testGame1.id);
-        expect(exists, true);
+        expect(exists, isTrue);
       });
 
       test('getAllGames() returns empty list when no games exist', () async {
@@ -199,7 +199,7 @@ void main() {
           gameId: testGame1.id,
           newName: newName,
         );
-        expect(updated, true);
+        expect(updated, isTrue);
 
         final updatedGame = await database.gameDao.getGameById(
           gameId: testGame1.id,
@@ -212,7 +212,7 @@ void main() {
           gameId: 'non-existent-id',
           newName: 'New name',
         );
-        expect(updated, false);
+        expect(updated, isFalse);
 
         final allGames = await database.gameDao.getAllGames();
         expect(allGames, isEmpty);
@@ -226,7 +226,7 @@ void main() {
           gameId: testGame1.id,
           newRuleset: ruleset,
         );
-        expect(updated, true);
+        expect(updated, isTrue);
 
         final updatedGame = await database.gameDao.getGameById(
           gameId: testGame1.id,
@@ -239,7 +239,7 @@ void main() {
           gameId: 'non-existent-id',
           newRuleset: Ruleset.lowestScore,
         );
-        expect(updated, false);
+        expect(updated, isFalse);
 
         final allGames = await database.gameDao.getAllGames();
         expect(allGames, isEmpty);
@@ -253,7 +253,7 @@ void main() {
           gameId: testGame1.id,
           newDescription: newDescription,
         );
-        expect(updated, true);
+        expect(updated, isTrue);
 
         final updatedGame = await database.gameDao.getGameById(
           gameId: testGame1.id,
@@ -268,7 +268,7 @@ void main() {
             gameId: 'non-existent-id',
             newDescription: 'New description',
           );
-          expect(updated, false);
+          expect(updated, isFalse);
 
           final allGames = await database.gameDao.getAllGames();
           expect(allGames, isEmpty);
@@ -294,7 +294,7 @@ void main() {
           gameId: 'non-existent-id',
           newColor: GameColor.green,
         );
-        expect(updated, false);
+        expect(updated, isFalse);
 
         final allGames = await database.gameDao.getAllGames();
         expect(allGames, isEmpty);
@@ -308,7 +308,7 @@ void main() {
           gameId: testGame1.id,
           newIcon: newIcon,
         );
-        expect(updated, true);
+        expect(updated, isTrue);
 
         final updatedGame = await database.gameDao.getGameById(
           gameId: testGame1.id,
@@ -321,7 +321,7 @@ void main() {
           gameId: 'non-existent-id',
           newIcon: 'New icon',
         );
-        expect(updated, false);
+        expect(updated, isFalse);
 
         final allGames = await database.gameDao.getAllGames();
         expect(allGames, isEmpty);
@@ -367,7 +367,7 @@ void main() {
         await database.gameDao.addGame(game: testGame1);
 
         final deleted = await database.gameDao.deleteGame(gameId: testGame1.id);
-        expect(deleted, true);
+        expect(deleted, isTrue);
 
         final allGames = await database.gameDao.getAllGames();
         expect(allGames, isEmpty);
@@ -377,7 +377,7 @@ void main() {
         final deleted = await database.gameDao.deleteGame(
           gameId: 'non-existent-id',
         );
-        expect(deleted, false);
+        expect(deleted, isFalse);
       });
 
       test('deleteAllGames() removes all games', () async {
@@ -389,7 +389,7 @@ void main() {
         expect(count, 3);
 
         final deleted = await database.gameDao.deleteAllGames();
-        expect(deleted, true);
+        expect(deleted, isTrue);
 
         count = await database.gameDao.getGameCount();
         expect(count, 0);
@@ -397,7 +397,7 @@ void main() {
 
       test('deleteAllGames() returns false when no games exist', () async {
         final deleted = await database.gameDao.deleteAllGames();
-        expect(deleted, false);
+        expect(deleted, isFalse);
       });
     });
   });

test/db_tests/entities/player_test.dart

@@ -94,15 +94,15 @@ void main() {
 
       test('addPlayer() returns false when player already exists', () async {
         var added = await database.playerDao.addPlayer(player: testPlayer1);
-        expect(added, true);
+        expect(added, isTrue);
 
         added = await database.playerDao.addPlayer(player: testPlayer1);
-        expect(added, false);
+        expect(added, isFalse);
       });
 
       test('addPlayersAsList() handles empty list correctly', () async {
         final added = await database.playerDao.addPlayersAsList(players: []);
-        expect(added, false);
+        expect(added, isFalse);
 
         final allPlayers = await database.playerDao.getAllPlayers();
         expect(allPlayers, isEmpty);
@@ -163,13 +163,13 @@ void main() {
         var playerExists = await database.playerDao.playerExists(
           playerId: testPlayer1.id,
         );
-        expect(playerExists, false);
+        expect(playerExists, isFalse);
 
         await database.playerDao.addPlayer(player: testPlayer1);
         playerExists = await database.playerDao.playerExists(
           playerId: testPlayer1.id,
         );
-        expect(playerExists, true);
+        expect(playerExists, isTrue);
       });
 
       test(
@@ -227,7 +227,7 @@ void main() {
           playerId: 'non-existent-id',
           newName: 'New name',
         );
-        expect(updated, false);
+        expect(updated, isFalse);
 
         final allPlayers = await database.playerDao.getAllPlayers();
         expect(allPlayers, isEmpty);
@@ -242,7 +242,7 @@ void main() {
           playerId: testPlayer1.id,
           newDescription: newDescription,
         );
-        expect(updated, true);
+        expect(updated, isTrue);
 
         final player = await database.playerDao.getPlayerById(
           playerId: testPlayer1.id,
@@ -257,7 +257,7 @@ void main() {
             playerId: 'non-existent-id',
             newDescription: 'New description',
           );
-          expect(updated, false);
+          expect(updated, isFalse);
 
           final allPlayers = await database.playerDao.getAllPlayers();
           expect(allPlayers, isEmpty);
@@ -305,19 +305,19 @@ void main() {
         final playerDeleted = await database.playerDao.deletePlayer(
           playerId: testPlayer1.id,
         );
-        expect(playerDeleted, true);
+        expect(playerDeleted, isTrue);
 
         final playerExists = await database.playerDao.playerExists(
           playerId: testPlayer1.id,
         );
-        expect(playerExists, false);
+        expect(playerExists, isFalse);
       });
 
       test('deletePlayer() returns false for non-existent player', () async {
         final deleted = await database.playerDao.deletePlayer(
           playerId: 'non-existent-id',
         );
-        expect(deleted, false);
+        expect(deleted, isFalse);
       });
 
       test('deleteAllPlayers() removes all players', () async {
@@ -329,7 +329,7 @@ void main() {
         expect(playerCount, 3);
 
         final deleted = await database.playerDao.deleteAllPlayers();
-        expect(deleted, true);
+        expect(deleted, isTrue);
 
         playerCount = await database.playerDao.getPlayerCount();
         expect(playerCount, 0);
@@ -337,7 +337,7 @@ void main() {
 
       test('deleteAllPlayers() returns false when no players exist', () async {
         final deleted = await database.playerDao.deleteAllPlayers();
-        expect(deleted, false);
+        expect(deleted, isFalse);
       });
     });
 
@@ -429,7 +429,7 @@ void main() {
           playerId: testPlayer1.id,
           nameCount: 2,
         );
-        expect(success, true);
+        expect(success, isTrue);
 
         final player = await database.playerDao.getPlayerById(
           playerId: testPlayer1.id,

test/db_tests/relationships/player_group_test.dart

@@ -56,7 +56,7 @@ void main() {
           playerId: testPlayer4.id,
         );
 
-        expect(playerAdded, true);
+        expect(playerAdded, isTrue);
       });
 
       test(
@@ -104,19 +104,19 @@ void main() {
             playerId: 'non-existent-player-id',
             groupId: testGroup.id,
           );
-          expect(isInGroup, false);
+          expect(isInGroup, isFalse);
 
           isInGroup = await database.playerGroupDao.isPlayerInGroup(
             playerId: testPlayer1.id,
             groupId: 'non-existent-group-id',
           );
-          expect(isInGroup, false);
+          expect(isInGroup, isFalse);
 
           isInGroup = await database.playerGroupDao.isPlayerInGroup(
             playerId: 'non-existent-player-id',
             groupId: 'non-existent-group-id',
           );
-          expect(isInGroup, false);
+          expect(isInGroup, isFalse);
         },
       );
 
@@ -174,8 +174,8 @@ void main() {
           groupId: testGroup.id,
         );
         expect(groupMembers.members.length, 2);
-        expect(groupMembers.members.any((p) => p.id == testPlayer3.id), true);
+        expect(groupMembers.members.any((p) => p.id == testPlayer3.id), isTrue);
-        expect(groupMembers.members.any((p) => p.id == testPlayer4.id), true);
+        expect(groupMembers.members.any((p) => p.id == testPlayer4.id), isTrue);
       });
     });
     group('DELETE', () {
@@ -186,7 +186,7 @@ void main() {
           playerId: testPlayer1.id,
           groupId: testGroup.id,
         );
-        expect(removed, true);
+        expect(removed, isTrue);
 
         final result = await database.groupDao.getGroupById(
           groupId: testGroup.id,
@@ -194,7 +194,7 @@ void main() {
         expect(result.members.length, testGroup.members.length - 1);
 
         final playerExists = result.members.any((p) => p.id == testPlayer1.id);
-        expect(playerExists, false);
+        expect(playerExists, isFalse);
       });
     });
 
@@ -216,7 +216,7 @@ void main() {
       final groupExists = await database.groupDao.groupExists(
         groupId: testGroup.id,
       );
-      expect(groupExists, true);
+      expect(groupExists, isTrue);
     });
 
     test('removePlayerFromGroup() works correctly', () async {
@@ -226,13 +226,13 @@ void main() {
         playerId: testPlayer1.id,
         groupId: testGroup.id,
       );
-      expect(removed, true);
+      expect(removed, isTrue);
 
       removed = await database.playerGroupDao.removePlayerFromGroup(
         playerId: testPlayer1.id,
         groupId: testGroup.id,
       );
-      expect(removed, false);
+      expect(removed, isFalse);
     });
 
     test(
@@ -246,19 +246,19 @@ void main() {
           playerId: 'non-existent-player-id',
           groupId: testGroup.id,
         );
-        expect(removed, false);
+        expect(removed, isFalse);
 
         removed = await database.playerGroupDao.removePlayerFromGroup(
           playerId: testPlayer1.id,
           groupId: 'non-existent-group-id',
         );
-        expect(removed, false);
+        expect(removed, isFalse);
 
         removed = await database.playerGroupDao.removePlayerFromGroup(
           playerId: 'non-existent-player-id',
           groupId: 'non-existent-group-id',
         );
-        expect(removed, false);
+        expect(removed, isFalse);
       },
     );
   });

test/db_tests/values/score_entry_test.dart

@@ -259,7 +259,7 @@ void main() {
           matchId: testMatch1.id,
         );
 
-        expect(scores.isEmpty, true);
+        expect(scores.isEmpty, isTrue);
       });
 
       test('getAllPlayerScoresInMatch() works correctly', () async {
@@ -299,7 +299,7 @@ void main() {
               matchId: testMatch1.id,
             );
 
-        expect(playerScores.isEmpty, true);
+        expect(playerScores.isEmpty, isTrue);
       });
 
       test('Scores are isolated across different matches', () async {
@@ -438,7 +438,7 @@ void main() {
           newEntry: newEntry,
         );
 
-        expect(updated, true);
+        expect(updated, isTrue);
 
         final score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
@@ -458,7 +458,7 @@ void main() {
           newEntry: entryRound1,
         );
 
-        expect(updated, false);
+        expect(updated, isFalse);
       });
     });
 
@@ -476,7 +476,7 @@ void main() {
           roundNumber: 1,
         );
 
-        expect(deleted, true);
+        expect(deleted, isTrue);
 
         final score = await database.scoreEntryDao.getScore(
           playerId: testPlayer1.id,
@@ -494,7 +494,7 @@ void main() {
           roundNumber: 1,
         );
 
-        expect(deleted, false);
+        expect(deleted, isFalse);
       });
 
       test('deleteAllScoresForMatch() works correctly', () async {
@@ -523,7 +523,7 @@ void main() {
           matchId: testMatch1.id,
         );
 
-        expect(deleted, true);
+        expect(deleted, isTrue);
 
         final match1Scores = await database.scoreEntryDao.getAllMatchScores(
           matchId: testMatch1.id,
@@ -555,7 +555,7 @@ void main() {
               matchId: testMatch1.id,
             );
 
-        expect(deleted, true);
+        expect(deleted, isTrue);
 
         final player1Scores = await database.scoreEntryDao
             .getAllPlayerScoresInMatch(
@@ -578,7 +578,7 @@ void main() {
         var hasWinner = await database.scoreEntryDao.hasWinner(
           matchId: testMatch1.id,
         );
-        expect(hasWinner, false);
+        expect(hasWinner, isFalse);
 
         await database.scoreEntryDao.setWinner(
           playerId: testPlayer1.id,
@@ -588,7 +588,7 @@ void main() {
         hasWinner = await database.scoreEntryDao.hasWinner(
           matchId: testMatch1.id,
         );
-        expect(hasWinner, true);
+        expect(hasWinner, isTrue);
       });
 
       test('getWinnersForMatch() returns correct winner', () async {
@@ -612,7 +612,7 @@ void main() {
         var removed = await database.scoreEntryDao.removeWinner(
           matchId: testMatch1.id,
         );
-        expect(removed, false);
+        expect(removed, isFalse);
 
         await database.scoreEntryDao.setWinner(
           playerId: testPlayer1.id,
@@ -622,7 +622,7 @@ void main() {
         removed = await database.scoreEntryDao.removeWinner(
           matchId: testMatch1.id,
         );
-        expect(removed, true);
+        expect(removed, isTrue);
 
         var winner = await database.scoreEntryDao.getWinner(
           matchId: testMatch1.id,
@@ -636,7 +636,7 @@ void main() {
         var hasLooser = await database.scoreEntryDao.hasLoser(
           matchId: testMatch1.id,
         );
-        expect(hasLooser, false);
+        expect(hasLooser, isFalse);
 
         await database.scoreEntryDao.setLoser(
           playerId: testPlayer1.id,
@@ -646,7 +646,7 @@ void main() {
         hasLooser = await database.scoreEntryDao.hasLoser(
           matchId: testMatch1.id,
         );
-        expect(hasLooser, true);
+        expect(hasLooser, isTrue);
       });
 
       test('getLoser() returns correct winner', () async {
@@ -670,7 +670,7 @@ void main() {
         var removed = await database.scoreEntryDao.removeLoser(
           matchId: testMatch1.id,
         );
-        expect(removed, false);
+        expect(removed, isFalse);
 
         await database.scoreEntryDao.setLoser(
           playerId: testPlayer1.id,
@@ -680,7 +680,7 @@ void main() {
         removed = await database.scoreEntryDao.removeLoser(
           matchId: testMatch1.id,
         );
-        expect(removed, true);
+        expect(removed, isTrue);
 
         var looser = await database.scoreEntryDao.getLoser(
           matchId: testMatch1.id,

test/services/data_transfer_service_test.dart

@@ -149,10 +149,10 @@ void main() {
 
           final decoded = json.decode(jsonString) as Map<String, dynamic>;
 
-          expect(decoded.containsKey('players'), true);
+          expect(decoded.containsKey('players'), isTrue);
-          expect(decoded.containsKey('games'), true);
+          expect(decoded.containsKey('games'), isTrue);
-          expect(decoded.containsKey('groups'), true);
+          expect(decoded.containsKey('groups'), isTrue);
-          expect(decoded.containsKey('matches'), true);
+          expect(decoded.containsKey('matches'), isTrue);
 
           final players = decoded['players'] as List<dynamic>;
           final games = decoded['games'] as List<dynamic>;