public async Task SetGuildLocaleAsyncTests() { await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Configs.LoadData(); this.Service.LoadData(this.ValidTestDataPath); Assert.That(await this.Service.SetGuildLocaleAsync(MockData.Ids[0], this.EnLocale), Is.True); }, verify : db => { Assert.That(db.Configs.Find((long)MockData.Ids[0]).Locale, Is.EqualTo(this.EnLocale)); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { GuildConfig gcfg = db.Configs.Find((long)MockData.Ids[0]); gcfg.Locale = this.EnLocale; db.Configs.Update(gcfg); return(db.SaveChangesAsync()); }, alter : async db => { this.Configs.LoadData(); this.Service.LoadData(this.ValidTestDataPath); Assert.That(await this.Service.SetGuildLocaleAsync(MockData.Ids[0], "non-existing-locale"), Is.False); }, verify : db => { Assert.That(db.Configs.Find((long)MockData.Ids[0]).Locale, Is.EqualTo(this.EnLocale)); return(Task.CompletedTask); } ); }
public async Task BlankDatabaseSyncTests() { this.Service.ChangeXp(MockData.Ids[0], MockData.Ids[0]); this.Service.ChangeXp(MockData.Ids[0], MockData.Ids[0]); for (int i = 0; i < 9; i++) { this.Service.ChangeXp(MockData.Ids[0], MockData.Ids[1]); } this.Service.ChangeXp(MockData.Ids[0], MockData.Ids[2]); await TestDbProvider.AlterAndVerifyAsync( alter : db => this.Service.Sync(), verify : db => { Assert.That(db.XpCounts, Has.Exactly(3).Items); XpCount u1 = db.XpCounts.Find((long)MockData.Ids[0], (long)MockData.Ids[0]); XpCount u2 = db.XpCounts.Find((long)MockData.Ids[0], (long)MockData.Ids[1]); XpCount u3 = db.XpCounts.Find((long)MockData.Ids[0], (long)MockData.Ids[2]); Assert.That(db.XpCounts.Find((long)MockData.Ids[0], 123451234512345), Is.Null); Assert.That(u1, Is.Not.Null); Assert.That(u2, Is.Not.Null); Assert.That(u3, Is.Not.Null); Assert.That(u1.Xp, Is.EqualTo(2)); Assert.That(u2.Xp, Is.EqualTo(9)); Assert.That(u3.Xp, Is.EqualTo(1)); return(Task.CompletedTask); } ); }
public async Task UnregisterGuildAsyncTests() { await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.LoadData(); await this.Service.UnregisterGuildAsync(MockData.Ids[0]); }, verify : async db => Assert.That(await db.Configs.FindAsync((long)MockData.Ids[0]), Is.Null) ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.LoadData(); await this.Service.UnregisterGuildAsync(1); }, verify : db => Task.CompletedTask ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.SetMockGuildConfig(db); return(Task.CompletedTask); }, alter : async db => { this.Service.LoadData(); await this.Service.UnregisterGuildAsync(MockData.Ids[0]); await this.Service.RegisterGuildAsync(MockData.Ids[0]); }, verify : async db => { GuildConfig gcfg = await db.Configs.FindAsync((long)MockData.Ids[0]); Assert.That(HaveSamePropertyValues(new CachedGuildConfig(), gcfg.CachedConfig)); } ); }
public async Task ContainsAsyncTests() { await TestDbProvider.AlterAndVerifyAsync( alter : _ => Task.CompletedTask, verify : async db => { foreach (ulong id in MockData.Ids) { Assert.That(await this.Service.ContainsAsync(id), Is.False); } } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockData(db); return(Task.CompletedTask); }, alter : _ => Task.CompletedTask, verify : async db => { Assert.That(await this.Service.ContainsAsync(MockData.Ids[0])); Assert.That(await this.Service.ContainsAsync(MockData.Ids[1])); foreach (ulong id in MockData.Ids.Skip(2)) { Assert.That(await this.Service.ContainsAsync(id), Is.False); } } ); }
public async Task GuildHasTextReactionTests() { TestDbProvider.SetupAlterAndVerify( setup: db => this.AddMockReactions(db), alter: db => this.Service.LoadData(), verify: db => { Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "abc"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "test"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "trigger me"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "y u DO dis"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "pls"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[1], "y u do dis"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[1], "rIck"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[1], "astLey"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[3], "test"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[3], "test(ing)?"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "asstley"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "abcd"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "ABCCC"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[1], "RICKY"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[2], "Ha"), Is.False); } ); TestDbProvider.AlterAndVerify( alter: db => this.Service.LoadData(), verify: db => { Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "abc"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "test"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "trigger me"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "y u DO dis"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "pls"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[1], "y u do dis"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[1], "rIck"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[1], "astLey"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "asstley"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "abcd"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "ABCCC"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[1], "RICK"), Is.False); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[2], "Ha"), Is.False); } ); await TestDbProvider.AlterAndVerifyAsync( alter : db => this.Service.AddTextReactionAsync(MockData.Ids[0], "test", "response", false), verify : db => { Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "test"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "teSt"), Is.True); Assert.That(this.Service.GuildHasTextReaction(MockData.Ids[0], "test"), Is.True); return(Task.CompletedTask); } ); }
public async Task AddAsyncTests() { await TestDbProvider.AlterAndVerifyAsync( alter : _ => this.Service.AddRuleAsync(MockData.Ids[0], "a", false, MockData.Ids[1]), verify : _ => { this.AssertIsBlocked(MockData.Ids[0], "a", blocked: new[] { MockData.Ids[1] }); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : _ => this.Service.AddRuleAsync(MockData.Ids[0], "a", true, MockData.Ids[1]), verify : db => { this.AssertIsBlocked(MockData.Ids[0], "a", allowed: new[] { MockData.Ids[1] }); return(Task.CompletedTask); } ); // TODO }
public async Task ModifyConfigAsyncTests() { await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.SetMockGuildConfig(db); return(Task.CompletedTask); }, alter : async db => { this.Service.LoadData(); await this.Service.ModifyConfigAsync(MockData.Ids[0], gcfg => gcfg.Prefix = "!!"); }, verify : async db => { GuildConfig gcfg = await db.Configs.FindAsync((long)MockData.Ids[0]); Assert.That(gcfg.Prefix, Is.EqualTo("!!")); Assert.That(this.Service.GetCachedConfig(MockData.Ids[0]), Is.Not.Null); Assert.That(this.Service.GetCachedConfig(MockData.Ids[0]).Prefix, Is.EqualTo("!!")); Assert.That((await this.Service.GetConfigAsync(MockData.Ids[0])).Prefix, Is.EqualTo("!!")); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.LoadData(); await this.Service.ModifyConfigAsync(MockData.Ids[1], gcfg => gcfg.AntispamSettings = new AntispamSettings { Action = PunishmentAction.TemporaryBan, Enabled = true, Sensitivity = 10 }); }, verify : async db => { GuildConfig gcfg = await db.Configs.FindAsync((long)MockData.Ids[1]); Assert.That(gcfg.AntispamEnabled, Is.True); Assert.That(gcfg.AntispamAction, Is.EqualTo(PunishmentAction.TemporaryBan)); Assert.That(gcfg.AntispamSensitivity, Is.EqualTo(10)); } ); }
public async Task BlockAsyncTests() { await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.Sync(); Assert.That(await this.Service.BlockChannelAsync(MockData.Ids[0]), Is.True); Assert.That(await this.Service.BlockChannelAsync(MockData.Ids[1], "Because I can!"), Is.True); Assert.That(await this.Service.BlockUserAsync(MockData.Ids[2]), Is.True); Assert.That(await this.Service.BlockUserAsync(MockData.Ids[3], "Some reason"), Is.True); }, verify : db => this.AssertBlockedAsync(db, bcExpected: new[] { MockData.Ids[0], MockData.Ids[1] }, buExpected: new[] { MockData.Ids[2], MockData.Ids[3] }, bcReasons: new[] { null, "Because I can!" }, buReasons: new[] { null, "Some reason" } ) ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.Sync(); Assert.That(await this.Service.BlockChannelAsync(MockData.Ids[0]), Is.True); Assert.That(await this.Service.BlockChannelAsync(MockData.Ids[1], "Because I can!"), Is.True); Assert.That(await this.Service.BlockUserAsync(MockData.Ids[0]), Is.True); Assert.That(await this.Service.BlockUserAsync(MockData.Ids[1], "Some reason"), Is.True); }, verify : db => this.AssertBlockedAsync(db, bcExpected: new[] { MockData.Ids[0], MockData.Ids[1] }, buExpected: new[] { MockData.Ids[0], MockData.Ids[1] }, bcReasons: new[] { null, "Because I can!" }, buReasons: new[] { null, "Some reason" } ) ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.Sync(); Assert.That(await this.Service.BlockChannelsAsync(new[] { MockData.Ids[0], MockData.Ids[1] }, "Because I can!"), Is.EqualTo(2)); Assert.That(await this.Service.BlockUsersAsync(new[] { MockData.Ids[0], MockData.Ids[1] }, "Some reason"), Is.EqualTo(2)); }, verify : db => this.AssertBlockedAsync(db, bcExpected: new[] { MockData.Ids[0], MockData.Ids[1] }, buExpected: new[] { MockData.Ids[0], MockData.Ids[1] }, bcReasons: new[] { "Because I can!", "Because I can!" }, buReasons: new[] { "Some reason", "Some reason" } ) ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.Sync(); Assert.That(await this.Service.BlockChannelsAsync(new[] { MockData.Ids[0], MockData.Ids[0] }, "Because I can!"), Is.EqualTo(1)); Assert.That(await this.Service.BlockUsersAsync(new[] { MockData.Ids[1], MockData.Ids[1] }, "Some reason"), Is.EqualTo(1)); }, verify : db => this.AssertBlockedAsync(db, bcExpected: new[] { MockData.Ids[0] }, buExpected: new[] { MockData.Ids[1] }, bcReasons: new[] { "Because I can!" }, buReasons: new[] { "Some reason" } ) ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockData(db); return(Task.CompletedTask); }, alter : async db => { this.Service.Sync(); Assert.That(await this.Service.BlockChannelsAsync(new[] { MockData.Ids[0], MockData.Ids[0] }, "Because I can!"), Is.Zero); Assert.That(await this.Service.BlockUsersAsync(new[] { MockData.Ids[1], MockData.Ids[1] }, "Some reason"), Is.EqualTo(1)); }, verify : db => this.AssertBlockedAsync(db, bcExpected: new[] { MockData.Ids[0], MockData.Ids[1], MockData.Ids[2] }, buExpected: new[] { MockData.Ids[0], MockData.Ids[1], MockData.Ids[4], MockData.Ids[5] }, bcReasons: new[] { "chn 1", "chn 1", "chn 2" }, buReasons: new[] { "usr 1", "usr 1", "usr 2", "Some reason" } ) ); }
public async Task RemoveForbiddenNamesAsyncTests() { { int[]? removed = null; await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); IReadOnlyCollection <ForbiddenName> fs = this.Service.GetGuildForbiddenNames(MockData.Ids[0]); removed = new[] { fs.First().Id, fs.Last().Id }; Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0], removed), Is.EqualTo(2)); Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0], removed), Is.Zero); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) - 2).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] - 2); AssertForbiddenNamesRemoved(db, 0, removed); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); IReadOnlyCollection <ForbiddenName> fs0 = this.Service.GetGuildForbiddenNames(MockData.Ids[0]); IReadOnlyCollection <ForbiddenName> fs1 = this.Service.GetGuildForbiddenNames(MockData.Ids[1]); removed = new[] { fs0.First().Id, fs1.First().Id }; Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0], removed), Is.EqualTo(1)); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) - 1).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] - 1); AssertForbiddenNamesRemoved(db, 0, removed); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); IReadOnlyCollection <ForbiddenName> fs = this.Service.GetGuildForbiddenNames(MockData.Ids[0]); removed = new[] { fs.First().Id, fs.Last().Id }; Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0], removed), Is.EqualTo(2)); Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0], removed), Is.Zero); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) - 2).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] - 2); AssertForbiddenNamesRemoved(db, 0, removed); return(Task.CompletedTask); } ); } { string[]? removed = null; await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); removed = new[] { "fish", @"i\ can\ haz\ spaces" }; Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0], removed), Is.EqualTo(2)); Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0], removed), Is.Zero); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) - 2).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] - 2); AssertForbiddenNamesRemoved(db, 0, removed?.Length ?? 0); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); removed = new[] { "fish", "doge" }; Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0], removed), Is.EqualTo(1)); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) - 1).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] - 1); AssertForbiddenNameRegexesRemoved(db, 0, removed); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); removed = new[] { "fish", "(fap)+" }; Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0], removed), Is.EqualTo(2)); Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0], removed), Is.Zero); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) - 2).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] - 2); AssertForbiddenNameRegexesRemoved(db, 0, removed); return(Task.CompletedTask); } ); } { int removedNum = 0; await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); int count = this.Service.GetGuildForbiddenNames(MockData.Ids[0]).Count; removedNum = await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0]); Assert.That(count, Is.EqualTo(removedNum)); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) - removedNum).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] - removedNum); for (int i = 1; i < MockData.Ids.Count; i++) { this.AssertGuildForbiddenNameCount(db, i, this.fnamesCount[i]); } return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0]), Is.Zero); }, verify : db => { Assert.That(db.ForbiddenNames, Is.Empty); for (int i = 0; i < MockData.Ids.Count; i++) { this.AssertGuildForbiddenNameCount(db, i, 0); } return(Task.CompletedTask); } ); } { int removedNum = 0; await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); removedNum = await this.Service.RemoveForbiddenNamesMatchingAsync(MockData.Ids[0], "doggy fish"); Assert.That(removedNum, Is.EqualTo(2)); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) - removedNum).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] - removedNum); for (int i = 1; i < MockData.Ids.Count; i++) { this.AssertGuildForbiddenNameCount(db, i, this.fnamesCount[i]); } return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); removedNum = await this.Service.RemoveForbiddenNamesMatchingAsync(MockData.Ids[0], "i can haz spaces and doge"); Assert.That(removedNum, Is.EqualTo(2)); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) - removedNum).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] - removedNum); for (int i = 1; i < MockData.Ids.Count; i++) { this.AssertGuildForbiddenNameCount(db, i, this.fnamesCount[i]); } return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => Assert.That(await this.Service.RemoveForbiddenNamesAsync(MockData.Ids[0]), Is.Zero), verify : db => { Assert.That(db.ForbiddenNames, Is.Empty); for (int i = 0; i < MockData.Ids.Count; i++) { this.AssertGuildForbiddenNameCount(db, i, 0); } return(Task.CompletedTask); } ); } void AssertForbiddenNamesRemoved(TheGodfatherDbContext db, ulong gid, params int[]?ids) { if (ids?.Any() ?? false) { Assert.That(db.ForbiddenNames.Where(f => f.GuildIdDb == (long)gid).Select(f => f.Id), Has.No.AnyOf(ids)); Assert.That(this.Service.GetGuildForbiddenNames(gid).Select(f => f.Id), Has.No.AnyOf(ids)); } else { Assert.Fail("No IDs provided to assert function."); } } void AssertForbiddenNameRegexesRemoved(TheGodfatherDbContext db, ulong gid, params string[]?regexStrings) { if (regexStrings?.Any() ?? false) { Assert.That(db.ForbiddenNames .Where(f => f.GuildIdDb == (long)gid) .AsEnumerable() .Any(f => regexStrings.Any(s => string.Compare(s, f.RegexString, true) == 0)), Is.False ); Assert.That(this.Service.GetGuildForbiddenNames(gid) .Any(f => regexStrings.Any(s => string.Compare(s, f.RegexString, true) == 0)), Is.False ); } else { Assert.Fail("No strings provided to assert function."); } } }
public async Task AddForbiddenNamesAsyncTests() { await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); Assert.That(await this.Service.AddForbiddenNamesAsync(MockData.Ids[0], new[] { "abcd", "efgh" }), Is.True); Assert.That(await this.Service.AddForbiddenNamesAsync(MockData.Ids[0], new[] { "tes?t" }), Is.True); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) + 3).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] + 3); this.AssertSingleAndTest(db, 0, "abcd", match: true, "This is a t for abcdef.", ".abcd.", "AbCd", "AABCDE", "-aBcd="); this.AssertSingleAndTest(db, 0, "abcd", match: false, "aabbccdd", "@bcd", "ABC"); this.AssertSingleAndTest(db, 0, "efgh", match: true, "This is a t for efghef.", ".efgh.", "EfGh", "EEFGHI", "-eFgH="); this.AssertSingleAndTest(db, 0, "efgh", match: false, "eeffgghh", "@fgh", "EFG"); this.AssertSingleAndTest(db, 0, "tes?t", match: true, "This is a test.", ".tet.", "teST.", "Testing", "-TeTing="); this.AssertSingleAndTest(db, 0, "tes?t", match: false, "tesst", "t3st", "teest"); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.UpdateForbiddenNameCount(db); Assert.That(await this.Service.AddForbiddenNamesAsync(MockData.Ids[0], new[] { "abcd", "ab+" }), Is.True); Assert.That(await this.Service.AddForbiddenNamesAsync(MockData.Ids[1], new[] { "abcd", "ab{4,}" }), Is.True); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) + 4).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] + 2); this.AssertGuildForbiddenNameCount(db, 1, this.fnamesCount[1] + 2); this.AssertSingleAndTest(db, 0, "abcd", match: true, "This is a test for abcdef.", ".abcd.", "AbCd", "AABCDE", "-aBcd="); this.AssertSingleAndTest(db, 0, "abcd", match: false, "aabbccdd", "@bcd", "ABC"); this.AssertSingleAndTest(db, 0, "ab+", match: true, "AbBbBbB.", ".ab.", "=Abbb.", "ABB", "-aBBBbcd="); this.AssertSingleAndTest(db, 0, "ab+", match: false, "acb", "@bB", "ACBC"); this.AssertSingleAndTest(db, 1, "abcd", match: true, "This is a test for abcdef.", ".abcd.", "AbCd", "AABCDE", "-aBcd="); this.AssertSingleAndTest(db, 1, "abcd", match: false, "aabbccdd", "@bcd", "ABC"); this.AssertSingleAndTest(db, 1, "ab{4,}", match: true, "This is a test for abbbb.", ".AbBbBbBbBbB.", "aBbBbbb", "Abbbb", "-AbBbBbasda="); this.AssertSingleAndTest(db, 1, "ab{4,}", match: false, "abbb", "@bbbbbb", "ABBCD"); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); Assert.That(await this.Service.AddForbiddenNamesAsync(MockData.Ids[0], new[] { "fish", "fish" }), Is.False); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value)).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0]); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.UpdateForbiddenNameCount(db); Assert.That(await this.Service.AddForbiddenNamesAsync(MockData.Ids[0], new[] { "fish", "fish" }), Is.False); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) + 1).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] + 1); return(Task.CompletedTask); } ); Assert.That(() => this.Service.AddForbiddenNamesAsync(0, new[] { "abc", "aaa**(" }), Throws.ArgumentException); }
public async Task AddForbiddenNameAsyncTests() { await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); Assert.That(await this.Service.AddForbiddenNameAsync(MockData.Ids[0], "abcd"), Is.True); Assert.That(await this.Service.AddForbiddenNameAsync(MockData.Ids[0], "tes?t"), Is.True); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) + 2).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] + 2); this.AssertSingleAndTest(db, 0, "abcd", match: true, "This is a for abcdef.", ".abcd.", "AbCd", "AABCDE", "-aBcd="); this.AssertSingleAndTest(db, 0, "abcd", match: false, "aabbccdd", "@bcd", "ABC"); this.AssertSingleAndTest(db, 0, "tes?t", match: true, "This is a test.", ".tet.", "teST.", "Testing", "-TeTing="); this.AssertSingleAndTest(db, 0, "tes?t", match: false, "tesst", "t3st", "teest"); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.UpdateForbiddenNameCount(db); Assert.That(await this.Service.AddForbiddenNameAsync(MockData.Ids[0], "abcd"), Is.True); Assert.That(await this.Service.AddForbiddenNameAsync(MockData.Ids[1], "abcd"), Is.True); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) + 2).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] + 1); this.AssertGuildForbiddenNameCount(db, 1, this.fnamesCount[1] + 1); this.AssertSingleAndTest(db, 0, "abcd", match: true, "This is a test for abcdef.", ".abcd.", "AbCd", "AABCDE", "-aBcd="); this.AssertSingleAndTest(db, 0, "abcd", match: false, "aabbccdd", "@bcd", "ABC"); this.AssertSingleAndTest(db, 1, "abcd", match: true, "This is a test for abcdef.", ".abcd.", "AbCd", "AABCDE", "-aBcd="); this.AssertSingleAndTest(db, 1, "abcd", match: false, "aabbccdd", "@bcd", "ABC"); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockForbiddenNames(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateForbiddenNameCount(db); Assert.That(await this.Service.AddForbiddenNameAsync(MockData.Ids[0], "fish"), Is.False); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value)).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0]); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.UpdateForbiddenNameCount(db); Assert.That(await this.Service.AddForbiddenNameAsync(MockData.Ids[0], "fish"), Is.True); Assert.That(await this.Service.AddForbiddenNameAsync(MockData.Ids[0], "fish"), Is.False); }, verify : db => { Assert.That(db.ForbiddenNames, Has.Exactly(this.fnamesCount.Sum(kvp => kvp.Value) + 1).Items); this.AssertGuildForbiddenNameCount(db, 0, this.fnamesCount[0] + 1); return(Task.CompletedTask); } ); Assert.That(() => this.Service.AddForbiddenNameAsync(0, "aaa**("), Throws.ArgumentException); }
public async Task AddTextReactionTests() { await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockReactions(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateTextReactionCount(db); this.Service.LoadData(); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "triggerino", "h3h3", false), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "regexp?", "regex response", true), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "another", "regex response", false), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "regexp", "different trigger even though it has collisions in some cases", false), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "triggerino", "already exists", false), Is.False); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "regexp?", "already exists", true), Is.False); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "test", "already exists", false), Is.False); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "kill", "already exists", false), Is.False); }, verify : db => { Assert.That(db.TextReactions, Has.Exactly(this.trCount.Sum(kvp => kvp.Value) + 3).Items); IReadOnlyCollection <TextReaction> trs = this.Service.GetGuildTextReactions(MockData.Ids[0]); Assert.That(trs, Has.Exactly(this.trCount[0] + 3).Items); Assert.That(trs.Select(tr => tr.Id), Is.Unique); Assert.That(trs.Select(tr => tr.Response), Is.Unique); AssertTextReactionExists(db, MockData.Ids[0], "h3h3", "triggerino"); AssertTextReactionExists(db, MockData.Ids[0], "regex response", "regexp?", "another"); AssertTextReactionExists(db, MockData.Ids[0], "different trigger even though it has collisions in some cases", "regexp"); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.LoadData(); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "trig", "h3h3", false), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[1], "trig", "h3h3", false), Is.True); }, verify : db => { Assert.That(db.TextReactions, Has.Exactly(2).Items); IReadOnlyCollection <TextReaction> trs0 = this.Service.GetGuildTextReactions(MockData.Ids[0]); Assert.That(trs0.Single(), Is.Not.Null); Assert.That(trs0.Single().IsMatch("This is a test for trig match")); IReadOnlyCollection <TextReaction> trs1 = this.Service.GetGuildTextReactions(MockData.Ids[1]); Assert.That(trs1.Single(), Is.Not.Null); Assert.That(trs1.Single().IsMatch("This is another 2tRiG@ example."), Is.False); AssertTextReactionExists(db, MockData.Ids[0], "h3h3", "trig"); AssertTextReactionExists(db, MockData.Ids[1], "h3h3", "trig"); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.LoadData(); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "trig+ered", "h3h3", true), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "not trig+ered", "not regex", false), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "tr1g", "h3h3 again", false), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "not trig+ered", "works because it is regex", true), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "tRigGggeReD", "h3h3", false), Is.True); }, verify : db => { Assert.That(db.TextReactions, Has.Exactly(4).Items); IReadOnlyCollection <TextReaction> trs = this.Service.GetGuildTextReactions(MockData.Ids[0]); Assert.That(trs, Has.Exactly(4).Items); Assert.That(trs.Single(tr => tr.IsMatch("I am triggered")), Is.Not.Null); Assert.That(trs.Single(tr => tr.IsMatch("I am nOt trig+ered")), Is.Not.Null); AssertTextReactionExists(db, MockData.Ids[0], "h3h3", "trig+ered", "triggggered"); AssertTextReactionExists(db, MockData.Ids[0], "not regex", @"not\ trig\+ered"); AssertTextReactionExists(db, MockData.Ids[0], "h3h3 again", "tr1g"); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.LoadData(); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], @"test(ing)?\ regex(es)?", "response", true), Is.True); }, verify : db => { Assert.That(db.TextReactions, Has.Exactly(1).Items); IReadOnlyCollection <TextReaction> trs = this.Service.GetGuildTextReactions(MockData.Ids[0]); Assert.That(trs, Has.Exactly(1).Items); AssertTextReactionExists(db, MockData.Ids[0], "response", @"test(ing)?\ regex(es)?"); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockReactions(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateTextReactionCount(db); this.Service.LoadData(); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], "test(ing)?regex(es)?", "response1", true), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[0], @"test(ing)?\ regex(es)?", "response1", true), Is.True); Assert.That(await this.Service.AddTextReactionAsync(MockData.Ids[1], "test(ing)?regex(es)?", "response12", true), Is.True); }, verify : db => { Assert.That(db.TextReactions, Has.Exactly(this.trCount.Sum(kvp => kvp.Value)).Items); AssertTextReactionExists(db, MockData.Ids[0], "response1", "test(ing)?regex(es)?", "abc", @"test(ing)?\ regex(es)?"); AssertTextReactionExists(db, MockData.Ids[1], "response12", "test(ing)?regex(es)?", "y u do dis"); return(Task.CompletedTask); } ); void AssertTextReactionExists(TheGodfatherDbContext db, ulong gid, string response, params string[] triggers) { if (triggers?.Any() ?? false) { Assert.That( db.TextReactions .Where(tr => tr.GuildIdDb == (long)gid) .AsEnumerable() .SingleOrDefault(tr => tr.Response == response && CheckTriggers(triggers, tr.DbTriggers.Select(t => t.Trigger.ToLower()))), Is.Not.Null ); Assert.That( this.Service.GetGuildTextReactions(gid).Single(tr => tr.Response == response && CheckTriggers(triggers, tr.Triggers)), Is.Not.Null );
public async Task RemoveEmojiReactionByEmojiTests() { await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockReactions(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateEmojiReactionCount(db); this.Service.LoadData(); Assert.That(await this.Service.RemoveEmojiReactionsAsync(MockData.Ids[0], Emojis.Information.GetDiscordName()), Is.Zero); }, verify : db => { Assert.That(db.EmojiReactions, Has.Exactly(this.erCount.Sum(kvp => kvp.Value)).Items); IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[0]); Assert.That(ers, Has.Exactly(this.erCount[0]).Items); Assert.That(ers.Any(er => er.Response == Emojis.Information.GetDiscordName()), Is.False); Assert.That( db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[0]) .AsEnumerable() .Any(er => er.Response == Emojis.Information.GetDiscordName()), Is.False ); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockReactions(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateEmojiReactionCount(db); this.Service.LoadData(); Assert.That(await this.Service.RemoveEmojiReactionsAsync(MockData.Ids[0], Emojis.Chicken.GetDiscordName()), Is.EqualTo(1)); }, verify : db => { Assert.That(db.EmojiReactions, Has.Exactly(this.erCount.Sum(kvp => kvp.Value) - 1).Items); Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[0]), Has.Exactly(this.erCount[0] - 1).Items); Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[1]), Has.Exactly(this.erCount[1]).Items); Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[0]).Any(er => er.Response == Emojis.Chicken.GetDiscordName()), Is.False); Assert.That( db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[0]) .AsEnumerable() .Any(er => er.Response == Emojis.Chicken.GetDiscordName()), Is.False ); Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[2]).Single(er => er.Response == Emojis.Chicken.GetDiscordName()), Is.Not.Null); Assert.That( db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[2]) .AsEnumerable() .Single(er => er.Response == Emojis.Chicken.GetDiscordName()), Is.Not.Null ); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.LoadData(); Assert.That(await this.Service.RemoveEmojiReactionsAsync(MockData.Ids[0], Emojis.Chicken.GetDiscordName()), Is.Zero); }, verify : db => { Assert.That(db.EmojiReactions, Is.Empty); Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[0]), Is.Empty); Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[1]), Is.Empty); return(Task.CompletedTask); } ); }
public async Task AddEmojiReactionTests() { await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockReactions(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateEmojiReactionCount(db); this.Service.LoadData(); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Information.GetDiscordName(), new[] { "test" }, false), Is.EqualTo(1) ); }, verify : db => { Assert.That(db.EmojiReactions, Has.Exactly(this.erCount.Sum(kvp => kvp.Value) + 1).Items); IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[0]); Assert.That(ers, Has.Exactly(this.erCount[0] + 1).Items); Assert.That(ers.Select(er => er.Id), Is.Unique); IEnumerable <EmojiReaction> x = db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[0]) .Include(er => er.DbTriggers) .AsEnumerable(); Assert.That( x.Single(er => er.Response == Emojis.Information.GetDiscordName() && er.DbTriggers.Single().Trigger == "test"), Is.Not.Null ); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.UpdateEmojiReactionCount(db); this.Service.LoadData(); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Information.GetDiscordName(), new[] { "test" }, false), Is.EqualTo(1) ); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[1], Emojis.Information.GetDiscordName(), new[] { "testing" }, false), Is.EqualTo(1) ); }, verify : db => { Assert.That(db.EmojiReactions, Has.Exactly(2).Items); IReadOnlyCollection <EmojiReaction> ers0 = this.Service.GetGuildEmojiReactions(MockData.Ids[0]); Assert.That(ers0, Has.Exactly(1).Items); Assert.That(ers0.First().Triggers, Has.Exactly(1).Items); Assert.That(ers0.First().IsMatch("This is a tEst")); IReadOnlyCollection <EmojiReaction> ers1 = this.Service.GetGuildEmojiReactions(MockData.Ids[1]); Assert.That(ers1, Has.Exactly(1).Items); Assert.That(ers1.First().Triggers, Has.Exactly(1).Items); Assert.That(ers1.First().IsMatch("This is another -teSting example.")); Assert.That( db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[0]) .AsEnumerable() .Single(er => er.Response == Emojis.Information.GetDiscordName() && er.DbTriggers.Single().Trigger == "test"), Is.Not.Null ); Assert.That( db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[1]) .AsEnumerable() .Single(er => er.Response == Emojis.Information.GetDiscordName() && er.DbTriggers.Single().Trigger == "testing"), Is.Not.Null ); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.UpdateEmojiReactionCount(db); this.Service.LoadData(); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Information.GetDiscordName(), new[] { "test" }, false), Is.EqualTo(1) ); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.AlarmClock.GetDiscordName(), new[] { "regex(es)? (much)+" }, false), Is.EqualTo(1) ); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Information.GetDiscordName(), new[] { "testing" }, false), Is.EqualTo(1) ); }, verify : db => { Assert.That(db.EmojiReactions, Has.Exactly(2).Items); IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[0]); Assert.That(ers, Has.Exactly(2).Items); EmojiReaction info = ers.Single(e => e.Response == Emojis.Information.GetDiscordName()); Assert.That(info.Triggers, Has.Exactly(2).Items); Assert.That(info.IsMatch("This is a tEst.")); Assert.That(info.IsMatch("This is a -tEsting.")); Assert.That(info.IsMatch("This is an alarm"), Is.False); Assert.That(info.IsMatch("This is a protEsting."), Is.False); Assert.That(ers.Any(e => e.IsMatch("here regex(es)? (much)+ will match because this is literal string interpretation"))); Assert.That( db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[0]) .AsEnumerable() .Single(er => er.Response == Emojis.Information.GetDiscordName() && er.DbTriggers.Count == 2 ), Is.Not.Null ); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.UpdateEmojiReactionCount(db); this.Service.LoadData(); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Information.GetDiscordName(), new[] { "test(ing)? regex(es)?" }, true), Is.EqualTo(1) ); }, verify : db => { Assert.That(db.EmojiReactions, Has.Exactly(1).Items); IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[0]); Assert.That(ers, Has.Exactly(1).Items); EmojiReaction info = ers.Single(e => e.Response == Emojis.Information.GetDiscordName()); Assert.That(info.Triggers, Has.Exactly(1).Items); Assert.That(info.IsMatch("This is a tEsting regexes example which passes")); Assert.That(info.IsMatch("This is another tEst regex example which passes")); Assert.That(info.IsMatch("This is another TEST rEGex example which passes")); Assert.That(info.IsMatch("This is a protesting regexes example which should not pass due to wb check"), Is.False); Assert.That(info.IsMatch("This is a tEst which wont pass"), Is.False); Assert.That(info.IsMatch("This is a literal test(ing)? regex(es)? string which wont pass"), Is.False); Assert.That( db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[0]) .AsEnumerable() .Single(er => er.Response == Emojis.Information.GetDiscordName() && er.DbTriggers.Count == 1 ), Is.Not.Null ); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockReactions(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateEmojiReactionCount(db); this.Service.LoadData(); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Information.GetDiscordName(), new[] { "test(ing)? regex(es)?" }, true), Is.EqualTo(1) ); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Information.GetDiscordName(), new[] { "another test" }, false), Is.EqualTo(1) ); }, verify : db => { Assert.That(db.EmojiReactions, Has.Exactly(this.erCount.Sum(kvp => kvp.Value) + 1).Items); IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[0]); Assert.That(ers, Has.Exactly(this.erCount[0] + 1).Items); EmojiReaction info = ers.Single(e => e.Response == Emojis.Information.GetDiscordName()); Assert.That(info.Triggers, Has.Exactly(2).Items); Assert.That(info.IsMatch("This is a tEsting regexes example which passes")); Assert.That(info.IsMatch("This is another tEst example which passes")); Assert.That(info.IsMatch("This is another tEst regex example which passes")); Assert.That(info.IsMatch("This is a another protesting regexes example which should not pass due to wb check"), Is.False); Assert.That(info.IsMatch("This is a tEst which wont pass"), Is.False); Assert.That(info.IsMatch("This is a literal test(ing)? regex(es)? string which wont pass"), Is.False); Assert.That( db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[0]) .AsEnumerable() .Single(er => er.Response == Emojis.Information.GetDiscordName() && er.DbTriggers.Count == 2 ), Is.Not.Null ); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockReactions(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateEmojiReactionCount(db); this.Service.LoadData(); Assert.That( await this.Service.AddEmojiReactionAsync( MockData.Ids[0], Emojis.Information.GetDiscordName(), new[] { "test(ing)? regex(es)?", "another test" }, true ), Is.EqualTo(2) ); }, verify : db => { Assert.That(db.EmojiReactions, Has.Exactly(this.erCount.Sum(kvp => kvp.Value) + 1).Items); IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[0]); Assert.That(ers, Has.Exactly(this.erCount[0] + 1).Items); EmojiReaction info = ers.Single(e => e.Response == Emojis.Information.GetDiscordName()); Assert.That(info.Triggers, Has.Exactly(2).Items); Assert.That(info.IsMatch("This is a tEsting regexes example which passes")); Assert.That(info.IsMatch("This is another tEst regex example which passes")); Assert.That(info.IsMatch("This is a tEst which wont pass"), Is.False); Assert.That(info.IsMatch("This is a another protesting regexes example which should not pass due to wb check"), Is.False); Assert.That(info.IsMatch("This is a literal test(ing)? regex(es)? string which wont pass"), Is.False); Assert.That( db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[0]) .AsEnumerable() .Single(er => er.Response == Emojis.Information.GetDiscordName() && er.DbTriggers.Count == 2 ), Is.Not.Null ); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockReactions(db); return(Task.CompletedTask); }, alter : async db => { this.UpdateEmojiReactionCount(db); this.Service.LoadData(); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Chicken.GetDiscordName(), new[] { "test(ing)? regex(es)?" }, true), Is.EqualTo(1) ); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Chicken.GetDiscordName(), new[] { "another test" }, true), Is.EqualTo(1) ); }, verify : db => { Assert.That(db.EmojiReactions, Has.Exactly(this.erCount.Sum(kvp => kvp.Value)).Items); IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[0]); Assert.That(ers, Has.Exactly(this.erCount[0]).Items); EmojiReaction info = ers.Single(e => e.Response == Emojis.Chicken.GetDiscordName()); Assert.That(info.Triggers, Has.Exactly(3).Items); Assert.That(info.IsMatch("This is old abc abc test which passes")); Assert.That(info.IsMatch("This is a tEsting regexes example which passes")); Assert.That(info.IsMatch("This is another tEst regex example which passes")); Assert.That(info.IsMatch("This is a tEst which wont pass"), Is.False); Assert.That(info.IsMatch("This is a another protesting regexes example which should not pass due to wb check"), Is.False); Assert.That(info.IsMatch("This is a literal test(ing)? regex(es)? string which wont pass"), Is.False); Assert.That( db.EmojiReactions .Where(er => er.GuildIdDb == (long)MockData.Ids[0]) .AsEnumerable() .Single(er => er.Response == Emojis.Chicken.GetDiscordName() && er.DbTriggers.Count == 3 ), Is.Not.Null ); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async db => { this.Service.LoadData(); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Chicken.GetDiscordName(), new[] { "test(ing)? regex(es)?" }, true), Is.EqualTo(1) ); Assert.That( await this.Service.AddEmojiReactionAsync(MockData.Ids[0], Emojis.Chicken.GetDiscordName(), new[] { "test(ing)? regex(es)?" }, false), Is.EqualTo(0) ); }, verify : db => { Assert.That(db.EmojiReactions, Has.Exactly(1).Items); Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[0]), Has.Exactly(1).Items); return(Task.CompletedTask); } ); }
public async Task AddAsyncTests() { int bef = 0; await TestDbProvider.AlterAndVerifyAsync( alter : async _ => Assert.That(await this.Service.AddAsync(MockData.Ids[0], MockData.Ids.Take(2)), Is.EqualTo(2)), verify : db => { Assert.That(this.Service.GetIds(MockData.Ids[0]), Is.EquivalentTo(MockData.Ids.Take(2))); Assert.That(db.AutoRoles, Has.Exactly(2).Items); Assert.That(this.GetGuildRoles(db, MockData.Ids[0]), Is.EquivalentTo(MockData.Ids.Take(2))); foreach (ulong gid in MockData.Ids.Skip(1)) { Assert.That(this.Service.GetIds(gid), Is.Empty); } return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockData(db); return(Task.CompletedTask); }, alter : async db => { bef = db.AutoRoles.Count(); Assert.That(await this.Service.AddAsync(MockData.Ids[0], MockData.Ids[2]), Is.EqualTo(1)); }, verify : db => { Assert.That(this.Service.GetIds(MockData.Ids[0]), Is.EquivalentTo(MockData.Ids.Take(3))); Assert.That(this.GetGuildRoles(db, MockData.Ids[0]), Is.EquivalentTo(MockData.Ids.Take(3))); Assert.That(db.AutoRoles, Has.Exactly(bef + 1).Items); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockData(db); return(Task.CompletedTask); }, alter : async db => { bef = db.AutoRoles.Count(); Assert.That(await this.Service.AddAsync(MockData.Ids[2], MockData.Ids[1]), Is.EqualTo(1)); Assert.That(await this.Service.AddAsync(MockData.Ids[2], MockData.Ids[1]), Is.EqualTo(0)); Assert.That(await this.Service.AddAsync(MockData.Ids[3], MockData.Ids[1], MockData.Ids[1]), Is.EqualTo(1)); Assert.That(await this.Service.AddAsync(MockData.Ids[0], MockData.Ids[0]), Is.EqualTo(0)); }, verify : db => { Assert.That(this.Service.GetIds(MockData.Ids[0]), Is.EquivalentTo(MockData.Ids.Take(2))); Assert.That(this.Service.GetIds(MockData.Ids[1]).Single(), Is.EqualTo(MockData.Ids[2])); Assert.That(this.Service.GetIds(MockData.Ids[2]).Single(), Is.EqualTo(MockData.Ids[1])); Assert.That(this.Service.GetIds(MockData.Ids[3]).Single(), Is.EqualTo(MockData.Ids[1])); Assert.That(db.AutoRoles, Has.Exactly(bef + 2).Items); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async _ => { foreach (ulong gid in MockData.Ids) { Assert.That(await this.Service.AddAsync(gid), Is.Zero); Assert.That(await this.Service.AddAsync(gid, null !), Is.Zero); Assert.That(await this.Service.AddAsync(gid, Array.Empty <ulong>()), Is.Zero); Assert.That(await this.Service.AddAsync(gid, Enumerable.Empty <ulong>()), Is.Zero); } }, verify : db => { Assert.That(db.AutoRoles, Is.Empty); foreach (ulong gid in MockData.Ids) { Assert.That(this.Service.GetIds(gid), Is.Empty); } return(Task.CompletedTask); } ); }
public async Task AddAsyncTests() { await TestDbProvider.AlterAndVerifyAsync( alter : async _ => Assert.That(await this.Service.AddAsync(MockData.Ids.Take(2)), Is.EqualTo(2)), verify : db => { Assert.That(this.Service.GetIds(), Is.EquivalentTo(MockData.Ids.Take(2))); Assert.That(db.PrivilegedUsers, Is.EquivalentTo(MockData.Ids.Take(2).Select(id => new PrivilegedUser { UserId = id }))); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockData(db); return(Task.CompletedTask); }, alter : async _ => Assert.That(await this.Service.AddAsync(MockData.Ids[2]), Is.EqualTo(1)), verify : db => { Assert.That(this.Service.GetIds(), Is.EquivalentTo(MockData.Ids.Take(3))); Assert.That(db.PrivilegedUsers, Is.EquivalentTo(MockData.Ids.Take(3).Select(id => new PrivilegedUser { UserId = id }))); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockData(db); return(Task.CompletedTask); }, alter : async _ => Assert.That(await this.Service.AddAsync(MockData.Ids[2]), Is.EqualTo(1)), verify : db => { Assert.That(this.Service.GetIds(), Is.EquivalentTo(MockData.Ids.Take(3))); Assert.That(db.PrivilegedUsers, Is.EquivalentTo(MockData.Ids.Take(3).Select(id => new PrivilegedUser { UserId = id }))); return(Task.CompletedTask); } ); await TestDbProvider.SetupAlterAndVerifyAsync( setup : db => { this.AddMockData(db); return(Task.CompletedTask); }, alter : async _ => { Assert.That(await this.Service.AddAsync(MockData.Ids[0], MockData.Ids[0]), Is.EqualTo(0)); Assert.That(await this.Service.AddAsync(MockData.Ids[0], MockData.Ids[1]), Is.EqualTo(0)); Assert.That(await this.Service.AddAsync(MockData.Ids[0], MockData.Ids[1], MockData.Ids[2]), Is.EqualTo(1)); Assert.That(await this.Service.AddAsync(MockData.Ids[0], MockData.Ids[1], MockData.Ids[2]), Is.EqualTo(0)); }, verify : db => { Assert.That(this.Service.GetIds(), Is.EquivalentTo(MockData.Ids.Take(3))); Assert.That(db.PrivilegedUsers, Is.EquivalentTo(MockData.Ids.Take(3).Select(id => new PrivilegedUser { UserId = id }))); return(Task.CompletedTask); } ); await TestDbProvider.AlterAndVerifyAsync( alter : async _ => { Assert.That(await this.Service.AddAsync(Array.Empty <ulong>()), Is.Zero); Assert.That(await this.Service.AddAsync(Enumerable.Empty <ulong>()), Is.Zero); }, verify : db => { Assert.That(this.Service.GetIds(), Is.Empty); Assert.That(db.PrivilegedUsers, Is.Empty); return(Task.CompletedTask); } ); }