public async Task TestSpeciesOverNameIfAmbiguous()
{
User user = MockUser("MockUser");
PkmnSpecies species = PkmnSpecies.RegisterName("1", "PersonMon");
_argsParser.AddArgumentParser(new PkmnSpeciesParser(new[] { species }));
User otherUser = MockUser("PersonMon");
_userRepoMock
.Setup(repo => repo.FindBySimpleName(otherUser.SimpleName))
.ReturnsAsync(otherUser);
_badgeRepoMock
.Setup(repo => repo.CountByUserAndSpecies(user.Id, species))
.ReturnsAsync(1);
_badgeRepoMock
.Setup(repo => repo.CountByUserPerSpecies(otherUser.Id))
.ReturnsAsync(ImmutableSortedDictionary <PkmnSpecies, int> .Empty);
CommandResult resultAmbiguous = await _badgeCommands.Badges(new CommandContext(MockMessage(user),
ImmutableList.Create("PersonMon"), _argsParser));
Assert.AreEqual("You have 1x #001 PersonMon badges.", resultAmbiguous.Response);
CommandResult resultDisambiguated = await _badgeCommands.Badges(new CommandContext(MockMessage(user),
ImmutableList.Create("@PersonMon"), _argsParser));
Assert.AreEqual("PersonMon has no badges.", resultDisambiguated.Response);
}
public async Task can_find_by_user()
{
IBadgeRepo badgeRepo = CreateBadgeRepo();
// given
Badge badgeUserA1 = await badgeRepo.AddBadge("userA", PkmnSpecies.OfId("1"), Badge.BadgeSource.Pinball);
Badge badgeUserA2 = await badgeRepo.AddBadge("userA", PkmnSpecies.OfId("2"), Badge.BadgeSource.Pinball);
Badge badgeUserB = await badgeRepo.AddBadge("userB", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
Badge badgeNobody = await badgeRepo.AddBadge(null, PkmnSpecies.OfId("4"), Badge.BadgeSource.Pinball);
// when
List <Badge> resultUserA = await badgeRepo.FindByUser("userA");
List <Badge> resultUserB = await badgeRepo.FindByUser("userB");
List <Badge> resultNobody = await badgeRepo.FindByUser(null);
// then
Assert.AreEqual(new List <Badge> {
badgeUserA1, badgeUserA2
}, resultUserA);
Assert.AreEqual(new List <Badge> {
badgeUserB
}, resultUserB);
Assert.AreEqual(new List <Badge> {
badgeNobody
}, resultNobody);
}
public async Task TestSpeciesAndUserInAnyOrder()
{
User user = MockUser("User");
PkmnSpecies species = PkmnSpecies.RegisterName("1", "Species");
_argsParser.AddArgumentParser(new PkmnSpeciesParser(new[] { species }));
_userRepoMock
.Setup(repo => repo.FindBySimpleName(user.SimpleName))
.ReturnsAsync(user);
_badgeRepoMock
.Setup(repo => repo.CountByUserAndSpecies(user.Id, species))
.ReturnsAsync(1);
_badgeRepoMock
.Setup(repo => repo.CountByUserPerSpecies(user.Id))
.ReturnsAsync(ImmutableSortedDictionary <PkmnSpecies, int> .Empty);
CommandResult result1 = await _badgeCommands.Badges(new CommandContext(MockMessage(user),
ImmutableList.Create("Species", "User"), _argsParser));
CommandResult result2 = await _badgeCommands.Badges(new CommandContext(MockMessage(user),
ImmutableList.Create("User", "Species"), _argsParser));
Assert.AreEqual(result1.Response, result2.Response);
Assert.AreEqual("User has 1x #001 Species badges.", result1.Response);
}
public async Task TestBadgesSelf()
{
User user = MockUser("MockUser");
var species1 = PkmnSpecies.RegisterName("1", "Einsmon");
var species2 = PkmnSpecies.RegisterName("22", "Zwozwomon");
var species3 = PkmnSpecies.RegisterName("13", "Drölfmon");
_userRepoMock
.Setup(repo => repo.FindBySimpleName(user.SimpleName))
.ReturnsAsync(user);
_badgeRepoMock
.Setup(repo => repo.CountByUserPerSpecies(user.Id))
.ReturnsAsync(new Dictionary <PkmnSpecies, int>
{
[species1] = 3,
[species2] = 6,
[species3] = 9,
}.ToImmutableSortedDictionary());
CommandResult result = await _badgeCommands.Badges(new CommandContext(MockMessage(user),
ImmutableList <string> .Empty, _argsParser));
const string response = "Your badges: 3x #001 Einsmon, 9x #013 Drölfmon, 6x #022 Zwozwomon";
Assert.AreEqual(response, result.Response);
}
public async Task TestPkmnSpeciesParser()
{
const string speciesId = "79317";
const string speciesName = "Uniquamon";
var argsParser = new ArgsParser();
PkmnSpecies species = PkmnSpecies.RegisterName(speciesId, speciesName);
argsParser.AddArgumentParser(new PkmnSpeciesParser(new[] { species }));
PkmnSpecies resultById = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("#" + speciesId));
PkmnSpecies resultByPaddedId = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("#0" + speciesId));
PkmnSpecies resultByName1 = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create(speciesName));
PkmnSpecies resultByName2 = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("uNiQuAmOn"));
Assert.AreEqual(species, resultById);
Assert.AreEqual(species, resultByPaddedId);
Assert.AreEqual(species, resultByName1);
Assert.AreEqual(species, resultByName2);
ArgsParseFailure exNotPrefixed = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <PkmnSpecies>(args: ImmutableList.Create(speciesId)));
Assert.AreEqual("Please prefix with '#' to supply and pokedex number", exNotPrefixed.Message);
ArgsParseFailure exUnknown = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <PkmnSpecies>(args: ImmutableList.Create("unknown")));
Assert.AreEqual(
"No pokemon with the name 'unknown' was recognized. Please supply a valid name, " +
"or prefix with '#' to supply and pokedex number instead", exUnknown.Message);
}
public async Task can_count_by_user_and_species()
{
IBadgeRepo badgeRepo = CreateBadgeRepo();
// given
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("2"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("userOther", PkmnSpecies.OfId("1"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("userOther", PkmnSpecies.OfId("2"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("userOther", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
// when
long countHasNone = await badgeRepo.CountByUserAndSpecies("user", PkmnSpecies.OfId("1"));
long countHasOne = await badgeRepo.CountByUserAndSpecies("user", PkmnSpecies.OfId("2"));
long countHasThree = await badgeRepo.CountByUserAndSpecies("user", PkmnSpecies.OfId("3"));
// then
Assert.AreEqual(0, countHasNone);
Assert.AreEqual(1, countHasOne);
Assert.AreEqual(3, countHasThree);
}
public async Task TestBadgesOther()
{
User user = MockUser("MockUser");
var species1 = PkmnSpecies.RegisterName("1", "Einsmon");
var species2 = PkmnSpecies.RegisterName("22", "Zwozwomon");
var species3 = PkmnSpecies.RegisterName("13", "Drölfmon");
_argsParser.AddArgumentParser(new PkmnSpeciesParser(new[] { species1, species2, species3 }));
User otherUser = MockUser("Someone_Else");
_userRepoMock
.Setup(repo => repo.FindBySimpleName(otherUser.SimpleName))
.ReturnsAsync(otherUser);
_badgeRepoMock
.Setup(repo => repo.CountByUserPerSpecies(otherUser.Id))
.ReturnsAsync(new Dictionary <PkmnSpecies, int>
{
[species1] = 12,
[species2] = 23,
[species3] = 34,
}.ToImmutableSortedDictionary());
CommandResult result = await _badgeCommands.Badges(new CommandContext(MockMessage(user),
ImmutableList.Create("sOmeOnE_eLsE"), _argsParser));
const string response =
"Someone_Else's badges: 12x #001 Einsmon, 34x #013 Drölfmon, 23x #022 Zwozwomon";
Assert.AreEqual(response, result.Response);
}
public void TestSpeciesIdLegality()
{
Assert.NotNull(PkmnSpecies.OfId("1"));
Assert.NotNull(PkmnSpecies.OfId("99999999"));
Assert.NotNull(PkmnSpecies.OfId("123-somedex"));
Assert.NotNull(PkmnSpecies.OfId("123-somedex-with-more-hyphens"));
Assert.Throws <ArgumentException>(() => PkmnSpecies.OfId("garbage"));
}
public async Task TestUnselectBadge()
{
PkmnSpecies species = PkmnSpecies.RegisterName("1", "Mon");
User user = MockUser("MockUser", selectedBadge: species);
CommandResult result = await _badgeCommands.UnselectBadge(new CommandContext(MockMessage(user),
ImmutableList <string> .Empty, _argsParser));
Assert.AreEqual("#001 Mon badge unequipped.", result.Response);
_userRepoMock.Verify(repo => repo.SetSelectedBadge(user, null), Times.Once());
}
public override PkmnSpecies?Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
if (context.Reader.CurrentBsonType == BsonType.Null)
{
context.Reader.ReadNull();
return(null);
}
else
{
return(PkmnSpecies.OfId(context.Reader.ReadString()));
}
}
public async Task insert_sets_current_timestamp_as_creation_date()
{
Mock <IClock> clockMock = new();
Instant createdAt = Instant.FromUnixTimeSeconds(123);
clockMock.Setup(c => c.GetCurrentInstant()).Returns(createdAt);
IBadgeRepo badgeRepo = new BadgeRepo(
CreateTemporaryDatabase(), Mock.Of <IMongoBadgeLogRepo>(), clockMock.Object);
Badge badge = await badgeRepo.AddBadge(null, PkmnSpecies.OfId("16"), Badge.BadgeSource.ManualCreation);
Assert.AreEqual(createdAt, badge.CreatedAt);
}
public void TestEqualsById()
{
PkmnSpecies instance1 = PkmnSpecies.OfId("16");
string name1 = instance1.Name;
PkmnSpecies.RegisterName("16", "Pidgey");
PkmnSpecies instance2 = PkmnSpecies.OfId("16");
string name2 = instance2.Name;
Assert.AreEqual(instance1, instance2);
Assert.IsTrue(instance1 == instance2);
Assert.AreNotEqual(name1, name2);
}
public async Task insert_then_read_are_equal()
{
BadgeRepo badgeRepo = CreateBadgeRepo();
// when
Badge badge = await badgeRepo.AddBadge(null, PkmnSpecies.OfId("16"), Badge.BadgeSource.ManualCreation);
// then
Assert.AreNotEqual(string.Empty, badge.Id);
Badge badgeFromDatabase = await badgeRepo.Collection.Find(b => b.Id == badge.Id).FirstOrDefaultAsync();
Assert.NotNull(badgeFromDatabase);
Assert.AreNotSame(badgeFromDatabase, badge);
Assert.AreEqual(badgeFromDatabase, badge);
}
public async Task TestSelectBadgeNotOwner()
{
User user = MockUser("MockUser");
PkmnSpecies species = PkmnSpecies.RegisterName("1", "Mon");
_argsParser.AddArgumentParser(new PkmnSpeciesParser(new[] { species }));
_badgeRepoMock.Setup(repo => repo.HasUserBadge(user.Id, species)).ReturnsAsync(false);
CommandResult result = await _badgeCommands.SelectBadge(new CommandContext(MockMessage(user),
ImmutableList.Create("#1"), _argsParser));
_userRepoMock.VerifyNoOtherCalls();
Assert.AreEqual("#001 Mon is not an owned badge.", result.Response);
}
public async Task <Badge> AddBadge(string?userId, PkmnSpecies species, Badge.BadgeSource source)
{
var badge = new Badge(
id: string.Empty,
userId: userId,
species: species,
source: source,
createdAt: Instant.FromUnixTimeSeconds(0)
);
await Collection.InsertOneAsync(badge);
Debug.Assert(badge.Id.Length > 0, "The MongoDB driver injected a generated ID");
return(badge);
}
public async Task <Badge> AddBadge(
string?userId, PkmnSpecies species, Badge.BadgeSource source, Instant?createdAt = null)
{
var badge = new Badge(
id: string.Empty,
userId: userId,
species: species,
source: source,
createdAt: createdAt ?? _clock.GetCurrentInstant()
);
await Collection.InsertOneAsync(badge);
Debug.Assert(badge.Id.Length > 0, "The MongoDB driver injected a generated ID");
return(badge);
}
public async Task <CommandResult> Badges(CommandContext context)
{
(Optional <PkmnSpecies> optionalSpecies, Optional <User> optionalUser) =
await context.ParseArgs <Optional <PkmnSpecies>, Optional <User> >();
Console.WriteLine($"species present: {optionalSpecies.IsPresent}");
Console.WriteLine($"user present: {optionalUser.IsPresent}");
bool isSelf = !optionalUser.IsPresent;
User user = isSelf ? context.Message.User : optionalUser.Value;
if (optionalSpecies.IsPresent)
{
PkmnSpecies species = optionalSpecies.Value;
long numBadges = await _badgeRepo.CountByUserAndSpecies(user.Id, species);
return(new CommandResult
{
Response = numBadges == 0
? isSelf
? $"You have no {species} badges."
: $"{user.Name} has no {species} badges."
: isSelf
? $"You have {numBadges}x {species} badges."
: $"{user.Name} has {numBadges}x {species} badges."
});
}
else
{
ImmutableSortedDictionary <PkmnSpecies, int> numBadgesPerSpecies =
await _badgeRepo.CountByUserPerSpecies(user.Id);
if (!numBadgesPerSpecies.Any())
{
return(new CommandResult
{
Response = isSelf ? "You have no badges." : $"{user.Name} has no badges."
});
}
IEnumerable <string> badgesFormatted = numBadgesPerSpecies.Select(kvp => $"{kvp.Value}x {kvp.Key}");
return(new CommandResult
{
Response = isSelf
? $"Your badges: {string.Join(", ", badgesFormatted)}"
: $"{user.Name}'s badges: {string.Join(", ", badgesFormatted)}",
ResponseTarget = ResponseTarget.WhisperIfLong
});
}
}
public void TestOrder()
{
var species = new List <PkmnSpecies>
{
PkmnSpecies.OfId("22"),
PkmnSpecies.OfId("5"),
PkmnSpecies.OfId("2-customdex"),
PkmnSpecies.OfId("11-customdex"),
};
List <string> sorted = species.OrderBy(p => p).Select(p => p.Id).ToList();
Assert.AreEqual(new List <string> {
"5", "22", "2-customdex", "11-customdex"
}, sorted);
}
public async Task has_expected_bson_datatypes()
{
BadgeRepo badgeRepo = CreateBadgeRepo();
// when
PkmnSpecies randomSpecies = PkmnSpecies.OfId("9001");
Badge badge = await badgeRepo.AddBadge(null, randomSpecies, Badge.BadgeSource.RunCaught);
// then
IMongoCollection <BsonDocument> badgesCollectionBson =
badgeRepo.Collection.Database.GetCollection <BsonDocument>("badges");
BsonDocument badgeBson = await badgesCollectionBson.Find(FilterDefinition <BsonDocument> .Empty).FirstAsync();
Assert.AreEqual(BsonObjectId.Create(ObjectId.Parse(badge.Id)), badgeBson["_id"]);
Assert.AreEqual(BsonNull.Value, badgeBson["user"]);
Assert.AreEqual(BsonString.Create(randomSpecies.Id), badgeBson["species"]);
Assert.AreEqual(BsonString.Create("run_caught"), badgeBson["source"]);
}
public void TestPokemonNames()
{
PkmnSpecies.RegisterName("1", "Bulbasaur");
PkmnSpecies.RegisterName("16", "Pidgey");
Assert.AreEqual("Bulbasaur", PkmnSpecies.OfId("1").Name);
Assert.AreEqual("Pidgey", PkmnSpecies.OfId("16").Name);
Assert.AreEqual("???", PkmnSpecies.OfId("123").Name);
Assert.IsNotNull(PkmnSpecies.OfIdWithKnownName("1"));
Assert.IsNotNull(PkmnSpecies.OfIdWithKnownName("16"));
Assert.IsNull(PkmnSpecies.OfIdWithKnownName("123"));
PkmnSpecies.ClearNames();
Assert.IsNull(PkmnSpecies.OfIdWithKnownName("1"));
Assert.IsNull(PkmnSpecies.OfIdWithKnownName("16"));
Assert.IsNull(PkmnSpecies.OfIdWithKnownName("123"));
}
public async Task TestPkmnSpeciesParserNameNormalization()
{
var argsParser = new ArgsParser();
PkmnSpecies species = PkmnSpecies.RegisterName("123", "'Mahina: -Pea.");
Regex removeCharsRegex = new Regex("[ '-.:]");
string NormalizeName(string name) => removeCharsRegex.Replace(name, "");
argsParser.AddArgumentParser(new PkmnSpeciesParser(new[] { species }, NormalizeName));
PkmnSpecies resultById = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("#123"));
PkmnSpecies result1 = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("mahina", "pea"));
PkmnSpecies result2 = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("mahina:", "-pea"));
PkmnSpecies result3 = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("MAHINA:pea"));
PkmnSpecies result4 = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("mahinaPEA"));
PkmnSpecies result5 = await argsParser.Parse <PkmnSpecies>(args : ImmutableList.Create("'mahina-pea."));
Assert.AreEqual(species, resultById);
Assert.AreEqual(species, result1);
Assert.AreEqual(species, result2);
Assert.AreEqual(species, result3);
Assert.AreEqual(species, result4);
Assert.AreEqual(species, result5);
ArgsParseFailure exNotRecognized = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <PkmnSpecies>(args: ImmutableList.Create("mahina", "aaaaaa")));
Assert.AreEqual(
"No pokemon with the name 'mahina' was recognized. Please supply a valid name, " +
"or prefix with '#' to supply and pokedex number instead", exNotRecognized.Message);
ArgsParseFailure exNoAccidentalHashRemoval = Assert.ThrowsAsync <ArgsParseFailure>(() => argsParser
.Parse <PkmnSpecies>(args: ImmutableList.Create("#mahinapea")));
Assert.AreEqual("did not recognize species '#mahinapea'", exNoAccidentalHashRemoval.Message);
}
public async Task can_count_per_species_for_one_user()
{
IBadgeRepo badgeRepo = CreateBadgeRepo();
// given
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("2"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("user", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("userOther", PkmnSpecies.OfId("1"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("userOther", PkmnSpecies.OfId("2"), Badge.BadgeSource.Pinball);
await badgeRepo.AddBadge("userOther", PkmnSpecies.OfId("3"), Badge.BadgeSource.Pinball);
// when
ImmutableSortedDictionary <PkmnSpecies, int> result = await badgeRepo.CountByUserPerSpecies("user");
// then
ImmutableSortedDictionary <PkmnSpecies, int> expected = new[]
public UserLostBadgeSpeciesEventArgs(string userId, PkmnSpecies species)
{
UserId = userId;
Species = species;
}
public async Task <bool> HasUserBadge(string?userId, PkmnSpecies species) => await Collection .Find(b => b.Species == species && b.UserId == userId) .AnyAsync();
public async Task <List <Badge> > FindByUserAndSpecies(string?userId, PkmnSpecies species) => await Collection.Find(b => b.UserId == userId && b.Species == species).ToListAsync();
public async Task <long> CountByUserAndSpecies(string?userId, PkmnSpecies species) => await Collection.CountDocumentsAsync(b => b.UserId == userId && b.Species == species);
