737 lines
21 KiB
Dart
737 lines
21 KiB
Dart
import 'package:clock/clock.dart';
|
|
import 'package:drift/drift.dart' hide isNull, isNotNull;
|
|
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/match.dart';
|
|
import 'package:game_tracker/data/dto/player.dart';
|
|
|
|
void main() {
|
|
late AppDatabase database;
|
|
late Player testPlayer1;
|
|
late Player testPlayer2;
|
|
late Player testPlayer3;
|
|
late Game testGame;
|
|
late Match testMatch1;
|
|
late Match testMatch2;
|
|
final fixedDate = DateTime(2025, 11, 19, 00, 11, 23);
|
|
final fakeClock = Clock(() => fixedDate);
|
|
|
|
setUp(() async {
|
|
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');
|
|
testGame = Game(name: 'Test Game', description: 'A test game', color: '0xFF000000');
|
|
testMatch1 = Match(
|
|
name: 'Test Match 1',
|
|
game: testGame,
|
|
players: [testPlayer1, testPlayer2],
|
|
);
|
|
testMatch2 = Match(
|
|
name: 'Test Match 2',
|
|
game: testGame,
|
|
players: [testPlayer2, testPlayer3],
|
|
);
|
|
});
|
|
|
|
await database.playerDao.addPlayersAsList(
|
|
players: [testPlayer1, testPlayer2, testPlayer3],
|
|
);
|
|
await database.gameDao.addGame(game: testGame);
|
|
await database.matchDao.addMatch(match: testMatch1);
|
|
await database.matchDao.addMatch(match: testMatch2);
|
|
});
|
|
|
|
tearDown(() async {
|
|
await database.close();
|
|
});
|
|
|
|
group('Score Tests', () {
|
|
|
|
// Verifies that a score can be added and retrieved with all fields intact.
|
|
test('Adding and fetching a score works correctly', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
|
|
final score = await database.scoreDao.getScoreForRound(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
);
|
|
|
|
expect(score, isNotNull);
|
|
expect(score!.playerId, testPlayer1.id);
|
|
expect(score.matchId, testMatch1.id);
|
|
expect(score.roundNumber, 1);
|
|
expect(score.score, 10);
|
|
expect(score.change, 10);
|
|
});
|
|
|
|
// Verifies that getScoresForMatch returns all scores for a given match.
|
|
test('Getting scores for a match works correctly', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer2.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 20,
|
|
change: 20,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 2,
|
|
score: 25,
|
|
change: 15,
|
|
);
|
|
|
|
final scores = await database.scoreDao.getScoresForMatch(
|
|
matchId: testMatch1.id,
|
|
);
|
|
|
|
expect(scores.length, 3);
|
|
});
|
|
|
|
// Verifies that getPlayerScoresInMatch returns all scores for a player in a match, ordered by round.
|
|
test('Getting player scores in a match works correctly', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 2,
|
|
score: 25,
|
|
change: 15,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 3,
|
|
score: 30,
|
|
change: 5,
|
|
);
|
|
|
|
final playerScores = await database.scoreDao.getPlayerScoresInMatch(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
);
|
|
|
|
expect(playerScores.length, 3);
|
|
expect(playerScores[0].roundNumber, 1);
|
|
expect(playerScores[1].roundNumber, 2);
|
|
expect(playerScores[2].roundNumber, 3);
|
|
expect(playerScores[0].score, 10);
|
|
expect(playerScores[1].score, 25);
|
|
expect(playerScores[2].score, 30);
|
|
});
|
|
|
|
// Verifies that getScoreForRound returns null for a non-existent round number.
|
|
test('Getting score for a non-existent round returns null', () async {
|
|
final score = await database.scoreDao.getScoreForRound(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 999,
|
|
);
|
|
|
|
expect(score, isNull);
|
|
});
|
|
|
|
// Verifies that updateScore correctly updates the score and change values.
|
|
test('Updating a score works correctly', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
|
|
final updated = await database.scoreDao.updateScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
newScore: 50,
|
|
newChange: 40,
|
|
);
|
|
|
|
expect(updated, true);
|
|
|
|
final score = await database.scoreDao.getScoreForRound(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
);
|
|
|
|
expect(score, isNotNull);
|
|
expect(score!.score, 50);
|
|
expect(score.change, 40);
|
|
});
|
|
|
|
// Verifies that updateScore returns false for a non-existent score entry.
|
|
test('Updating a non-existent score returns false', () async {
|
|
final updated = await database.scoreDao.updateScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 999,
|
|
newScore: 50,
|
|
newChange: 40,
|
|
);
|
|
|
|
expect(updated, false);
|
|
});
|
|
|
|
// Verifies that deleteScore removes the score entry and returns true.
|
|
test('Deleting a score works correctly', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
|
|
final deleted = await database.scoreDao.deleteScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
);
|
|
|
|
expect(deleted, true);
|
|
|
|
final score = await database.scoreDao.getScoreForRound(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
);
|
|
|
|
expect(score, isNull);
|
|
});
|
|
|
|
// Verifies that deleteScore returns false for a non-existent score entry.
|
|
test('Deleting a non-existent score returns false', () async {
|
|
final deleted = await database.scoreDao.deleteScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 999,
|
|
);
|
|
|
|
expect(deleted, false);
|
|
});
|
|
|
|
// Verifies that deleteScoresForMatch removes all scores for a match but keeps other match scores.
|
|
test('Deleting scores for a match works correctly', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer2.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 20,
|
|
change: 20,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch2.id,
|
|
roundNumber: 1,
|
|
score: 15,
|
|
change: 15,
|
|
);
|
|
|
|
final deleted = await database.scoreDao.deleteScoresForMatch(
|
|
matchId: testMatch1.id,
|
|
);
|
|
|
|
expect(deleted, true);
|
|
|
|
final match1Scores = await database.scoreDao.getScoresForMatch(
|
|
matchId: testMatch1.id,
|
|
);
|
|
expect(match1Scores.length, 0);
|
|
|
|
final match2Scores = await database.scoreDao.getScoresForMatch(
|
|
matchId: testMatch2.id,
|
|
);
|
|
expect(match2Scores.length, 1);
|
|
});
|
|
|
|
// Verifies that deleteScoresForPlayer removes all scores for a player across all matches.
|
|
test('Deleting scores for a player works correctly', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch2.id,
|
|
roundNumber: 1,
|
|
score: 15,
|
|
change: 15,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer2.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 20,
|
|
change: 20,
|
|
);
|
|
|
|
final deleted = await database.scoreDao.deleteScoresForPlayer(
|
|
playerId: testPlayer1.id,
|
|
);
|
|
|
|
expect(deleted, true);
|
|
|
|
final player1Scores = await database.scoreDao.getPlayerScoresInMatch(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
);
|
|
expect(player1Scores.length, 0);
|
|
|
|
final player2Scores = await database.scoreDao.getPlayerScoresInMatch(
|
|
playerId: testPlayer2.id,
|
|
matchId: testMatch1.id,
|
|
);
|
|
expect(player2Scores.length, 1);
|
|
});
|
|
|
|
// Verifies that getLatestRoundNumber returns the highest round number for a match.
|
|
test('Getting latest round number works correctly', () async {
|
|
var latestRound = await database.scoreDao.getLatestRoundNumber(
|
|
matchId: testMatch1.id,
|
|
);
|
|
expect(latestRound, 0);
|
|
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
|
|
latestRound = await database.scoreDao.getLatestRoundNumber(
|
|
matchId: testMatch1.id,
|
|
);
|
|
expect(latestRound, 1);
|
|
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 5,
|
|
score: 50,
|
|
change: 40,
|
|
);
|
|
|
|
latestRound = await database.scoreDao.getLatestRoundNumber(
|
|
matchId: testMatch1.id,
|
|
);
|
|
expect(latestRound, 5);
|
|
});
|
|
|
|
// Verifies that getTotalScoreForPlayer returns the latest score (cumulative) for a player.
|
|
test('Getting total score for a player works correctly', () async {
|
|
var totalScore = await database.scoreDao.getTotalScoreForPlayer(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
);
|
|
expect(totalScore, 0);
|
|
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 2,
|
|
score: 25,
|
|
change: 15,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 3,
|
|
score: 40,
|
|
change: 15,
|
|
);
|
|
|
|
totalScore = await database.scoreDao.getTotalScoreForPlayer(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
);
|
|
expect(totalScore, 40);
|
|
});
|
|
|
|
// Verifies that adding a score with the same player/match/round replaces the existing one.
|
|
test('Adding the same score twice replaces the existing one', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 99,
|
|
change: 99,
|
|
);
|
|
|
|
final score = await database.scoreDao.getScoreForRound(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
);
|
|
|
|
expect(score, isNotNull);
|
|
expect(score!.score, 99);
|
|
expect(score.change, 99);
|
|
});
|
|
|
|
// Verifies that getScoresForMatch returns empty list for match with no scores.
|
|
test('Getting scores for match with no scores returns empty list', () async {
|
|
final scores = await database.scoreDao.getScoresForMatch(
|
|
matchId: testMatch1.id,
|
|
);
|
|
|
|
expect(scores.isEmpty, true);
|
|
});
|
|
|
|
// Verifies that getPlayerScoresInMatch returns empty list when player has no scores.
|
|
test('Getting player scores with no scores returns empty list', () async {
|
|
final playerScores = await database.scoreDao.getPlayerScoresInMatch(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
);
|
|
|
|
expect(playerScores.isEmpty, true);
|
|
});
|
|
|
|
// Verifies that scores can have negative values.
|
|
test('Score can have negative values', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: -10,
|
|
change: -10,
|
|
);
|
|
|
|
final score = await database.scoreDao.getScoreForRound(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
);
|
|
|
|
expect(score, isNotNull);
|
|
expect(score!.score, -10);
|
|
expect(score.change, -10);
|
|
});
|
|
|
|
// Verifies that scores can have zero values.
|
|
test('Score can have zero values', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 0,
|
|
change: 0,
|
|
);
|
|
|
|
final score = await database.scoreDao.getScoreForRound(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
);
|
|
|
|
expect(score, isNotNull);
|
|
expect(score!.score, 0);
|
|
expect(score.change, 0);
|
|
});
|
|
|
|
// Verifies that very large round numbers are supported.
|
|
test('Score supports very large round numbers', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 999999,
|
|
score: 100,
|
|
change: 100,
|
|
);
|
|
|
|
final score = await database.scoreDao.getScoreForRound(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 999999,
|
|
);
|
|
|
|
expect(score, isNotNull);
|
|
expect(score!.roundNumber, 999999);
|
|
});
|
|
|
|
// Verifies that getLatestRoundNumber returns max correctly for non-consecutive rounds.
|
|
test('Getting latest round number with non-consecutive rounds', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 5,
|
|
score: 50,
|
|
change: 40,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 3,
|
|
score: 30,
|
|
change: 20,
|
|
);
|
|
|
|
final latestRound = await database.scoreDao.getLatestRoundNumber(
|
|
matchId: testMatch1.id,
|
|
);
|
|
|
|
expect(latestRound, 5);
|
|
});
|
|
|
|
// Verifies that deleteScoresForMatch returns false when no scores exist.
|
|
test('Deleting scores for empty match returns false', () async {
|
|
final deleted = await database.scoreDao.deleteScoresForMatch(
|
|
matchId: testMatch1.id,
|
|
);
|
|
|
|
expect(deleted, false);
|
|
});
|
|
|
|
// Verifies that deleteScoresForPlayer returns false when player has no scores.
|
|
test('Deleting scores for player with no scores returns false', () async {
|
|
final deleted = await database.scoreDao.deleteScoresForPlayer(
|
|
playerId: testPlayer1.id,
|
|
);
|
|
|
|
expect(deleted, false);
|
|
});
|
|
|
|
// Verifies that multiple players in same match can have independent score updates.
|
|
test('Multiple players in same match have independent scores', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer2.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 20,
|
|
change: 20,
|
|
);
|
|
|
|
await database.scoreDao.updateScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
newScore: 100,
|
|
newChange: 90,
|
|
);
|
|
|
|
final player1Score = await database.scoreDao.getScoreForRound(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
);
|
|
final player2Score = await database.scoreDao.getScoreForRound(
|
|
playerId: testPlayer2.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
);
|
|
|
|
expect(player1Score!.score, 100);
|
|
expect(player2Score!.score, 20);
|
|
});
|
|
|
|
// Verifies that scores are isolated across different matches.
|
|
test('Scores are isolated across different matches', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch2.id,
|
|
roundNumber: 1,
|
|
score: 50,
|
|
change: 50,
|
|
);
|
|
|
|
final match1Scores = await database.scoreDao.getPlayerScoresInMatch(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
);
|
|
final match2Scores = await database.scoreDao.getPlayerScoresInMatch(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch2.id,
|
|
);
|
|
|
|
expect(match1Scores.length, 1);
|
|
expect(match2Scores.length, 1);
|
|
expect(match1Scores[0].score, 10);
|
|
expect(match2Scores[0].score, 50);
|
|
});
|
|
|
|
// Verifies that getTotalScoreForPlayer returns latest score across multiple rounds.
|
|
test('Total score for player returns latest cumulative score', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 2,
|
|
score: 25,
|
|
change: 25,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 3,
|
|
score: 50,
|
|
change: 25,
|
|
);
|
|
|
|
final totalScore = await database.scoreDao.getTotalScoreForPlayer(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
);
|
|
|
|
// Should return the highest round's score
|
|
expect(totalScore, 50);
|
|
});
|
|
|
|
// Verifies that updating one player's score doesn't affect another player's score in same round.
|
|
test('Updating one player score does not affect other players in same round', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer2.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 20,
|
|
change: 20,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer3.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 30,
|
|
change: 30,
|
|
);
|
|
|
|
await database.scoreDao.updateScore(
|
|
playerId: testPlayer2.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
newScore: 99,
|
|
newChange: 89,
|
|
);
|
|
|
|
final scores = await database.scoreDao.getScoresForMatch(
|
|
matchId: testMatch1.id,
|
|
);
|
|
|
|
expect(scores.length, 3);
|
|
expect(scores.where((s) => s.playerId == testPlayer1.id).first.score, 10);
|
|
expect(scores.where((s) => s.playerId == testPlayer2.id).first.score, 99);
|
|
expect(scores.where((s) => s.playerId == testPlayer3.id).first.score, 30);
|
|
});
|
|
|
|
// Verifies that deleting a player's scores only affects that specific player.
|
|
test('Deleting player scores only affects target player', () async {
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer1.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 10,
|
|
change: 10,
|
|
);
|
|
await database.scoreDao.addScore(
|
|
playerId: testPlayer2.id,
|
|
matchId: testMatch1.id,
|
|
roundNumber: 1,
|
|
score: 20,
|
|
change: 20,
|
|
);
|
|
|
|
await database.scoreDao.deleteScoresForPlayer(
|
|
playerId: testPlayer1.id,
|
|
);
|
|
|
|
final match1Scores = await database.scoreDao.getScoresForMatch(
|
|
matchId: testMatch1.id,
|
|
);
|
|
|
|
expect(match1Scores.length, 1);
|
|
expect(match1Scores[0].playerId, testPlayer2.id);
|
|
});
|
|
});
|
|
}
|