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);