public async Task AddMultipleTeams()
{
ByCommandTeamManager teamManager = new ByCommandTeamManager();
Assert.IsTrue(teamManager.TryAddTeam(FirstTeam, out _), "Couldn't add the first team");
Assert.IsTrue(
teamManager.TryAddTeam(SecondTeam, out _), "Couldn't add the second team");
Assert.IsTrue(
teamManager.TryAddPlayerToTeam(FirstPlayerId, FirstPlayerName, FirstTeam), "Couldn't add the first player");
Assert.IsTrue(
teamManager.TryAddPlayerToTeam(SecondPlayerId, SecondPlayerName, SecondTeam),
"Couldn't add the second player");
IEnumerable <PlayerTeamPair> pairs = await teamManager.GetKnownPlayers();
Assert.AreEqual(2, pairs.Count(), "Unexpected number of known players");
PlayerTeamPair firstPair = pairs.FirstOrDefault(pair => pair.PlayerId == FirstPlayerId);
Assert.IsNotNull(firstPair, "Couldn't find the first player");
Assert.AreEqual(FirstTeam, firstPair.TeamId, "First player has the wrong team");
Assert.AreEqual(FirstPlayerName, firstPair.PlayerDisplayName, "First player has the wrong name");
PlayerTeamPair secondPair = pairs.FirstOrDefault(pair => pair.PlayerId == SecondPlayerId);
Assert.IsNotNull(secondPair, "Couldn't find the second player");
Assert.AreEqual(SecondTeam, secondPair.TeamId, "First player has the wrong team");
Assert.AreEqual(SecondPlayerName, secondPair.PlayerDisplayName, "Second player has the wrong name");
}
public async Task AddingSamePlayerToDifferentTeam()
{
ByCommandTeamManager teamManager = new ByCommandTeamManager();
Assert.IsTrue(teamManager.TryAddTeam(FirstTeam, out _), "Couldn't add the first team");
Assert.IsTrue(teamManager.TryAddTeam(SecondTeam, out _), "Couldn't add the second team");
Assert.IsTrue(
teamManager.TryAddPlayerToTeam(FirstPlayerId, FirstPlayerName, FirstTeam),
"Couldn't add player to team");
IEnumerable <PlayerTeamPair> pairs = await teamManager.GetKnownPlayers();
Assert.AreEqual(1, pairs.Count(), "Unexpected number of players");
PlayerTeamPair pair = pairs.First();
Assert.AreEqual(FirstPlayerId, pair.PlayerId, "Player should be known");
Assert.AreEqual(FirstTeam, pair.TeamId, "Player should be on the first team");
Assert.AreEqual(FirstPlayerName, pair.PlayerDisplayName, "Player should have the same display name");
Assert.IsTrue(
teamManager.TryAddPlayerToTeam(FirstPlayerId, FirstPlayerName, SecondTeam),
"Should be able to add the same player to the same team (as a no-op)");
pairs = await teamManager.GetKnownPlayers();
Assert.AreEqual(1, pairs.Count(), "Unexpected number of players after the second add");
pair = pairs.First();
Assert.AreEqual(FirstPlayerId, pair.PlayerId, "Player should still be known");
Assert.AreEqual(FirstPlayerName, pair.PlayerDisplayName, "Player should still have the same display name");
Assert.AreEqual(SecondTeam, pair.TeamId, "Player should be on the second team");
}
public async Task SetRostersWithNoRolesInChannelSucceeds()
{
PlayerTeamPair[] playerTeamPairs = new PlayerTeamPair[]
{
new PlayerTeamPair(1, "Alice", FirstTeam),
new PlayerTeamPair(2, "Alan", FirstTeam),
new PlayerTeamPair(3, "Bob", SecondTeam)
};
IEnumerable <IGrouping <string, PlayerTeamPair> > grouping = playerTeamPairs.GroupBy(pair => pair.TeamId);
IReadOnlyDictionary <string, string> teamIdToNames = playerTeamPairs
.Select(pair => pair.TeamId)
.Distinct()
.ToDictionary(key => key);
Mock <IByRoleTeamManager> mockTeamManager = new Mock <IByRoleTeamManager>();
mockTeamManager
.Setup(manager => manager.GetTeamIdToNamesForServer())
.Returns(Task.FromResult(teamIdToNames));
mockTeamManager
.Setup(manager => manager.GetPlayerTeamPairsForServer())
.Returns(Task.FromResult(grouping));
mockTeamManager
.Setup(manager => manager.GetTeamIdToNames())
.Returns(Task.FromResult <IReadOnlyDictionary <string, string> >(new Dictionary <string, string>()));
mockTeamManager
.Setup(manager => manager.GetKnownPlayers())
.Returns(Task.FromResult(Enumerable.Empty <PlayerTeamPair>()));
IByRoleTeamManager teamManager = mockTeamManager.Object;
await ValidateDefaultRostersSet(teamManager);
}
public async Task BuzzAndNoPenalty()
{
this.CreateHandler(
out MessageHandler handler,
out GameState state,
out IGuildUser playerUser,
out IGuildUser readerUser,
out IGuildTextChannel channel,
out MessageStore messageStore);
await handler.HandlePlayerMessage(state, playerUser, channel, "buzz");
messageStore.VerifyChannelMessages(playerUser.Mention);
messageStore.Clear();
await handler.TryScore(state, readerUser, channel, "no penalty");
IReadOnlyDictionary <PlayerTeamPair, LastScoringSplit> lastSplits = await state.GetLastScoringSplits();
PlayerTeamPair pair = new PlayerTeamPair(DefaultPlayerId, playerUser.Username, null);
Assert.IsTrue(
lastSplits.TryGetValue(pair, out LastScoringSplit split),
"Couldn't get scoring split");
Assert.AreEqual(0, split.Split.Points, "Unexpected number of points");
messageStore.VerifyChannelMessages();
}
private async Task VerifyBuzzAndScore(int score)
{
this.CreateHandler(
out MessageHandler handler,
out GameState state,
out IGuildUser playerUser,
out IGuildUser readerUser,
out IGuildTextChannel channel,
out MessageStore messageStore);
await handler.HandlePlayerMessage(state, playerUser, channel, "buzz");
messageStore.VerifyChannelMessages(playerUser.Mention);
messageStore.Clear();
bool scoredBuzz = await handler.TryScore(
state, readerUser, channel, score.ToString(CultureInfo.InvariantCulture));
Assert.IsTrue(scoredBuzz, "Buzz wasn't scored");
IReadOnlyDictionary <PlayerTeamPair, LastScoringSplit> lastSplits = await state.GetLastScoringSplits();
PlayerTeamPair pair = new PlayerTeamPair(DefaultPlayerId, playerUser.Username, null);
Assert.IsTrue(
lastSplits.TryGetValue(pair, out LastScoringSplit split),
"Couldn't get scoring split");
Assert.AreEqual(score, split.Split.Points, "Unexpected number of points");
if (score > 0)
{
messageStore.VerifyChannelMessages("**TU 2**");
}
}
public async Task OnlyReaderCanScore()
{
this.CreateHandler(
out MessageHandler handler,
out GameState state,
out IGuildUser playerUser,
out IGuildUser readerUser,
out IGuildTextChannel channel,
out MessageStore messageStore);
await state.AddPlayer(DefaultPlayerId, "Player");
bool scoredBuzz = await handler.TryScore(state, playerUser, channel, "no penalty");
Assert.IsFalse(scoredBuzz, "Player shouldn't be able to give points");
IReadOnlyDictionary <PlayerTeamPair, LastScoringSplit> lastSplits = await state.GetLastScoringSplits();
PlayerTeamPair pair = new PlayerTeamPair(DefaultPlayerId, "Player", null);
Assert.IsFalse(lastSplits.TryGetValue(pair, out _), "Scoring split shouldn't exist");
scoredBuzz = await handler.TryScore(state, readerUser, channel, "10");
Assert.IsTrue(scoredBuzz, "Buzz wasn't scored");
lastSplits = await state.GetLastScoringSplits();
Assert.IsTrue(
lastSplits.TryGetValue(pair, out LastScoringSplit split),
"Couldn't get scoring split");;
Assert.AreEqual(10, split.Split.Points, "Unexpected number of points");
messageStore.VerifyChannelMessages("**TU 2**");
}
public async Task TryCreateScoresheetWithMoreThanTwoTeamsFails()
{
PlayerTeamPair[] players = new PlayerTeamPair[3];
for (int i = 0; i < players.Length; i++)
{
players[i] = new PlayerTeamPair((ulong)i + 100, $"Player{i}", $"Team{i}");
}
IByRoleTeamManager teamManager = CreateTeamManager(players);
GameState game = new GameState()
{
Format = Format.CreateTossupBonusesShootout(false),
ReaderId = 1,
TeamManager = teamManager
};
await game.AddPlayer(2, "Alice");
game.ScorePlayer(10);
IResult <string> result = await this.Generator.TryCreateScoresheet(game, SheetsUri, 1);
Assert.IsFalse(result.Success, $"Creation succeeded when it should've failed.");
Assert.AreEqual(
"Couldn't write to the sheet. Export only works if there are 1 or 2 teams in the game.",
result.ErrorMessage,
"Unexpected error message");
}
protected override IResult <List <ValueRange> > GetUpdateRangesForRoster(
IReadOnlyDictionary <string, string> teamIdToNames,
IEnumerable <IGrouping <string, PlayerTeamPair> > groupings)
{
int row = 2;
List <ValueRange> ranges = new List <ValueRange>();
foreach (IGrouping <string, PlayerTeamPair> grouping in groupings)
{
PlayerTeamPair firstPair = grouping.First();
if (!teamIdToNames.TryGetValue(firstPair.TeamId, out string teamName))
{
// It's not a team, but an individual player. Use their name.
teamName = firstPair.PlayerDisplayName;
}
IEnumerable <string> playerNames = grouping.Select(pair => pair.PlayerDisplayName);
IEnumerable <string> rowValues = new string[] { teamName }
.Concat(playerNames);
ranges.Add(CreateUpdateCellsAlongRowRequest(RostersSheetName, FirstColumn, row, rowValues));
row++;
}
return(new SuccessResult <List <ValueRange> >(ranges));
}
public async Task AddingPlayerToTeam()
{
ByCommandTeamManager teamManager = new ByCommandTeamManager();
Assert.IsTrue(teamManager.TryAddTeam(FirstTeam, out _), "Couldn't add team");
Assert.IsTrue(
teamManager.TryAddPlayerToTeam(FirstPlayerId, FirstPlayerName, FirstTeam),
"Couldn't add player to team");
IEnumerable <PlayerTeamPair> pairs = await teamManager.GetKnownPlayers();
Assert.AreEqual(1, pairs.Count(), "Unexpected number of players");
PlayerTeamPair pair = pairs.First();
Assert.AreEqual(FirstPlayerId, pair.PlayerId, "Player should be known");
Assert.AreEqual(FirstTeam, pair.TeamId, "Player should be on the first team");
}
public async Task GetKnownPlayers()
{
ByRoleTeamManager teamManager = CreateTeamManager();
IEnumerable <PlayerTeamPair> pairs = await teamManager.GetKnownPlayers();
Assert.AreEqual(PlayerIds.Length, pairs.Count(), "Unexpected number of players");
for (int i = 0; i < PlayerIds.Length; i++)
{
PlayerTeamPair pair = pairs.FirstOrDefault(pair => pair.PlayerId == PlayerIds[i]);
Assert.IsNotNull(pair, $"Couldn't find the player #{i + 1}");
Assert.AreEqual(
RoleIds[i].ToString(CultureInfo.InvariantCulture),
pair.TeamId,
$"Unexpected team ID for player #{i + 1}");
}
}
public async Task CannotRemoveNonexistentPlayerFromTeam()
{
ByCommandTeamManager teamManager = new ByCommandTeamManager();
Assert.IsTrue(teamManager.TryAddTeam(FirstTeam, out _), "Couldn't add team");
Assert.IsTrue(
teamManager.TryAddPlayerToTeam(FirstPlayerId, FirstPlayerName, FirstTeam),
"Couldn't add player to team");
Assert.IsFalse(teamManager.TryRemovePlayerFromTeam(SecondPlayerId), "Second player shouldn't be removable");
IEnumerable <PlayerTeamPair> pairs = await teamManager.GetKnownPlayers();
Assert.AreEqual(1, pairs.Count(), "Unexpected number of players");
PlayerTeamPair pair = pairs.First();
Assert.AreEqual(FirstPlayerId, pair.PlayerId, "Player should be known");
Assert.AreEqual(FirstTeam, pair.TeamId, "Player should be on the first team");
Assert.AreEqual(FirstPlayerName, pair.PlayerDisplayName, "Player should have a name");
}
public async Task TeamIncludedInScore()
{
const ulong firstPlayerId = 1;
const ulong secondPlayerId = 3;
const string firstPlayerName = "Player1";
const string secondPlayerName = "Player2";
const string firstTeamId = "Team1";
const string secondTeamId = "Team2";
GameState gameState = CreateGameStateWithByCommandTeamManager(out ByCommandTeamManager teamManager);
Assert.IsTrue(teamManager.TryAddTeam(firstTeamId, out _), "Couldn't add the first team");
Assert.IsTrue(teamManager.TryAddTeam(secondTeamId, out _), "Couldn't add the second team");
teamManager.TryAddPlayerToTeam(firstPlayerId, firstPlayerName, firstTeamId);
teamManager.TryAddPlayerToTeam(secondPlayerId, secondPlayerName, secondTeamId);
Assert.IsTrue(
await gameState.AddPlayer(firstPlayerId, firstPlayerName), "Add should succeed the first time");
gameState.ScorePlayer(10);
Assert.IsTrue(
await gameState.AddPlayer(secondPlayerId, secondPlayerName), "Add should succeed the third time");
gameState.ScorePlayer(15);
IReadOnlyDictionary <PlayerTeamPair, LastScoringSplit> lastSplits = await gameState.GetLastScoringSplits();
PlayerTeamPair firstPair = new PlayerTeamPair(firstPlayerId, firstPlayerName, firstTeamId);
Assert.IsTrue(
lastSplits.TryGetValue(firstPair, out LastScoringSplit split),
"Couldn't find split for the first player");
Assert.AreEqual(10, split.Split.Points, "Unexpected score for the first player");
Assert.AreEqual(firstTeamId, split.TeamId, "Unexpected team ID for the first player's buzz");
PlayerTeamPair secondPair = new PlayerTeamPair(secondPlayerId, secondPlayerName, secondTeamId);
Assert.IsTrue(
lastSplits.TryGetValue(secondPair, out split), "Couldn't find split for the second player");
Assert.AreEqual(15, split.Split.Points, "Unexpected score for the second player");
Assert.AreEqual(secondTeamId, split.TeamId, "Unexpected team ID for the second player's buzz");
}
public async Task AddingPlayerToRemovedTeam()
{
ByCommandTeamManager teamManager = new ByCommandTeamManager();
Assert.IsTrue(teamManager.TryAddTeam(FirstTeam, out _), "Couldn't add team");
IReadOnlyDictionary <string, string> teamIdToName = await teamManager.GetTeamIdToNames();
Assert.IsTrue(teamIdToName.ContainsKey(FirstTeam), "Couldn't find team after adding it");
Assert.IsTrue(
teamManager.TryAddPlayerToTeam(FirstPlayerId, FirstPlayerName, FirstTeam),
"Couldn't add player to team");
IEnumerable <PlayerTeamPair> pairs = await teamManager.GetKnownPlayers();
Assert.AreEqual(1, pairs.Count(), "Unexpected number of players");
PlayerTeamPair pair = pairs.First();
Assert.AreEqual(FirstPlayerId, pair.PlayerId, "Player should be known");
Assert.AreEqual(FirstTeam, pair.TeamId, "Player should be on the first team");
Assert.AreEqual(FirstPlayerName, pair.PlayerDisplayName, "Player should have a name");
}
protected static IByRoleTeamManager CreateTeamManager(params PlayerTeamPair[] playerTeamPairs)
{
IEnumerable <IGrouping <string, PlayerTeamPair> > grouping = playerTeamPairs.GroupBy(pair => pair.TeamId);
IReadOnlyDictionary <string, string> teamIdToNames = playerTeamPairs
.Select(pair => pair.TeamId)
.Distinct()
.ToDictionary(key => key);
Mock <IByRoleTeamManager> mockTeamManager = new Mock <IByRoleTeamManager>();
mockTeamManager
.Setup(manager => manager.GetTeamIdToNamesForServer())
.Returns(Task.FromResult(teamIdToNames));
mockTeamManager
.Setup(manager => manager.GetPlayerTeamPairsForServer())
.Returns(Task.FromResult(grouping));
mockTeamManager
.Setup(manager => manager.GetTeamIdToNames())
.Returns(Task.FromResult(teamIdToNames));
mockTeamManager
.Setup(manager => manager.GetKnownPlayers())
.Returns(Task.FromResult <IEnumerable <PlayerTeamPair> >(playerTeamPairs));
mockTeamManager
.Setup(manager => manager.GetTeamIdOrNull(It.IsAny <ulong>()))
.Returns <ulong>((userId) =>
{
PlayerTeamPair player = playerTeamPairs.FirstOrDefault(player => player.PlayerId == userId);
return(Task.FromResult(
player != null && teamIdToNames.TryGetValue(player.TeamId, out string teamId) ?
teamId :
(string)null));
});
return(mockTeamManager.Object);
}
