public void IsBlockedTests()
{
foreach (ulong uid in MockData.Ids)
{
Assert.That(this.Service.IsChannelBlocked(MockData.Ids[0]), Is.False);
Assert.That(this.Service.IsUserBlocked(MockData.Ids[0]), Is.False);
}
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockData(db),
alter: db => this.Service.LoadData(),
verify: db => {
Assert.That(this.Service.IsChannelBlocked(MockData.Ids[0]));
Assert.That(this.Service.IsChannelBlocked(MockData.Ids[1]));
Assert.That(this.Service.IsChannelBlocked(MockData.Ids[2]));
Assert.That(this.Service.IsChannelBlocked(MockData.Ids[3]), Is.False);
Assert.That(this.Service.IsChannelBlocked(MockData.Ids[4]), Is.False);
Assert.That(this.Service.IsChannelBlocked(MockData.Ids[5]), Is.False);
Assert.That(this.Service.IsUserBlocked(MockData.Ids[0]));
Assert.That(this.Service.IsUserBlocked(MockData.Ids[1]), Is.False);
Assert.That(this.Service.IsUserBlocked(MockData.Ids[2]), Is.False);
Assert.That(this.Service.IsUserBlocked(MockData.Ids[3]), Is.False);
Assert.That(this.Service.IsUserBlocked(MockData.Ids[4]));
Assert.That(this.Service.IsBlocked(MockData.Ids[0], cid: MockData.Ids[0], uid: MockData.Ids[1]));
Assert.That(this.Service.IsBlocked(MockData.Ids[0], cid: MockData.Ids[3], uid: MockData.Ids[4]));
Assert.That(this.Service.IsBlocked(MockData.Ids[0], cid: MockData.Ids[3], uid: MockData.Ids[3]), Is.False);
Assert.That(this.Service.IsBlocked(MockData.Ids[0], cid: MockData.Ids[4], uid: MockData.Ids[2]), Is.False);
}
);
}
public void GetLocalizedTimeTests()
{
TestDbProvider.SetupAlterAndVerify(
setup: db => {
GuildConfig gcfg;
gcfg = db.Configs.Find((long)MockData.Ids[0]);
gcfg.TimezoneId = null;
gcfg.Locale = this.SrLocale;
db.Configs.Update(gcfg);
gcfg = db.Configs.Find((long)MockData.Ids[1]);
gcfg.TimezoneId = "UTC";
gcfg.Locale = "en-US";
db.Configs.Update(gcfg);
},
alter: db => {
this.Configs.LoadData();
this.Service.LoadData(this.ValidTestDataPath);
},
verify: db => {
var dt = new DateTime(2020, 1, 1, 12, 0, 0, DateTimeKind.Utc);
var dto = new DateTimeOffset(2020, 1, 1, 12, 0, 0, TimeSpan.FromHours(1));
Assert.That(this.Service.GetLocalizedTimeString(MockData.Ids[0], dt, "G"), Is.EqualTo("2020-01-01 13:00:00"));
Assert.That(this.Service.GetLocalizedTimeString(MockData.Ids[1], dt), Is.EqualTo("1/1/2020 12:00 PM"));
Assert.That(this.Service.GetLocalizedTimeString(MockData.Ids[0], dt, "r"), Is.EqualTo("Wed, 01 Jan 2020 12:00:00 GMT"));
Assert.That(this.Service.GetLocalizedTimeString(MockData.Ids[1], dt, "r"), Is.EqualTo("Wed, 01 Jan 2020 12:00:00 GMT"));
Assert.That(this.Service.GetLocalizedTimeString(MockData.Ids[0], dto), Is.EqualTo("2020-01-01 12:00"));
Assert.That(this.Service.GetLocalizedTimeString(MockData.Ids[1], dto, "G"), Is.EqualTo("1/1/2020 11:00:00 AM"));
Assert.That(this.Service.GetLocalizedTimeString(MockData.Ids[0], dto, "r"), Is.EqualTo("Wed, 01 Jan 2020 11:00:00 GMT"));
Assert.That(this.Service.GetLocalizedTimeString(MockData.Ids[1], dto, "r"), Is.EqualTo("Wed, 01 Jan 2020 11:00:00 GMT"));
}
);
}
public void GetTests()
{
TestDbProvider.AlterAndVerify(
alter: _ => { },
verify: db => {
foreach (ulong id in MockData.Ids)
{
IReadOnlyList <ulong> all = this.Service.GetIds(id);
Assert.That(all, Is.Empty);
}
}
);
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockData(db),
alter: _ => { },
verify: db => {
IReadOnlyList <ulong> gid0 = this.Service.GetIds(MockData.Ids[0]);
Assert.That(gid0, Is.EquivalentTo(new[] { MockData.Ids[0], MockData.Ids[1] }));
IReadOnlyList <ulong> gid1 = this.Service.GetIds(MockData.Ids[1]);
Assert.That(gid1, Is.EquivalentTo(new[] { MockData.Ids[2] }));
foreach (ulong id in MockData.Ids.Skip(2))
{
IReadOnlyList <ulong> gidx = this.Service.GetIds(id);
Assert.That(gidx, Is.Empty);
}
}
);
}
public void GetCommandDescriptionTests()
{
this.Service.LoadData(this.ValidTestDataPath);
Assert.That(this.Service.GetCommandDescription(MockData.Ids[0], "cmd1"), Is.EqualTo("one"));
Assert.That(this.Service.GetCommandDescription(MockData.Ids[0], "cmd2"), Is.EqualTo("two"));
Assert.That(this.Service.GetCommandDescription(MockData.Ids[0], "cmd1 subcommand"), Is.EqualTo("one sub"));
Assert.That(() => this.Service.GetCommandDescription(MockData.Ids[0], "does not exist"), Throws.InstanceOf <LocalizationException>());
Assert.That(this.Service.GetCommandDescription(MockData.Ids[1], "cmd1"), Is.EqualTo("one"));
Assert.That(this.Service.GetCommandDescription(MockData.Ids[1], "cmd2"), Is.EqualTo("two"));
Assert.That(this.Service.GetCommandDescription(MockData.Ids[1], "cmd1 subcommand"), Is.EqualTo("one sub"));
TestDbProvider.SetupAlterAndVerify(
setup: db => {
GuildConfig gcfg = db.Configs.Find((long)MockData.Ids[1]);
gcfg.Locale = this.SrLocale;
db.Configs.Update(gcfg);
},
alter: db => {
this.Configs.LoadData();
this.Service.LoadData(this.ValidTestDataPath);
},
verify: db => {
Assert.That(this.Service.GetCommandDescription(MockData.Ids[0], "cmd1"), Is.EqualTo("one"));
Assert.That(this.Service.GetCommandDescription(MockData.Ids[0], "cmd2"), Is.EqualTo("two"));
Assert.That(this.Service.GetCommandDescription(MockData.Ids[0], "cmd1 subcommand"), Is.EqualTo("one sub"));
Assert.That(() => this.Service.GetCommandDescription(MockData.Ids[0], "does not exist"), Throws.InstanceOf <LocalizationException>());
Assert.That(this.Service.GetCommandDescription(MockData.Ids[1], "cmd2"), Is.EqualTo("dva"));
Assert.That(this.Service.GetCommandDescription(MockData.Ids[1], "cmd3"), Is.EqualTo("tri"));
Assert.That(this.Service.GetCommandDescription(MockData.Ids[1], "cmd1 subcommand"), Is.EqualTo("jedan pod"));
Assert.That(() => this.Service.GetCommandDescription(MockData.Ids[1], "does not exist"), Throws.InstanceOf <LocalizationException>());
}
);
}
public void ClearAsyncTests()
{
TestDbProvider.Verify(
verify: _ => {
foreach (ulong gid in MockData.Ids)
{
Assert.DoesNotThrowAsync(() => this.Service.ClearAsync(gid));
Assert.DoesNotThrowAsync(() => this.Service.ClearAsync(gid));
}
}
);
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockRules(db),
alter: db => Assert.DoesNotThrowAsync(() => this.Service.ClearAsync(MockData.Ids[0])),
verify: db => {
Assert.That(this.Service.GetRules(MockData.Ids[0]), Is.Empty);
Assert.That(this.Service.GetRules(MockData.Ids[1]), Is.Not.Empty);
Assert.That(this.Service.GetRules(MockData.Ids[2]), Is.Not.Empty);
}
);
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockRules(db),
alter: db => {
foreach (ulong gid in MockData.Ids)
{
Assert.DoesNotThrowAsync(() => this.Service.ClearAsync(gid));
Assert.DoesNotThrowAsync(() => this.Service.ClearAsync(gid));
}
},
verify: db => Assert.That(db.CommandRules, Is.Empty)
);
}
public void IsChannelExemptedTests()
{
TestDbProvider.SetupAlterAndVerify(
setup: db => {
db.ExemptsLogging.Add(new ExemptedLoggingEntity {
GuildId = MockData.Ids[0], Id = MockData.Ids[0], Type = ExemptedEntityType.Channel
});
db.ExemptsLogging.Add(new ExemptedLoggingEntity {
GuildId = MockData.Ids[1], Id = MockData.Ids[0], Type = ExemptedEntityType.Channel
});
db.ExemptsLogging.Add(new ExemptedLoggingEntity {
GuildId = MockData.Ids[2], Id = MockData.Ids[1], Type = ExemptedEntityType.Channel
});
db.ExemptsLogging.Add(new ExemptedLoggingEntity {
GuildId = MockData.Ids[3], Id = MockData.Ids[2], Type = ExemptedEntityType.Channel
});
},
alter: db => this.Service.LoadData(),
verify: db => {
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[0], cid: MockData.Ids[0]), Is.True);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[1], cid: MockData.Ids[0]), Is.True);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[2], cid: MockData.Ids[1]), Is.True);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[3], cid: MockData.Ids[2]), Is.True);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[0], cid: MockData.Ids[1]), Is.False);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[1], cid: MockData.Ids[1]), Is.False);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[2], cid: MockData.Ids[2]), Is.False);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[3], cid: MockData.Ids[3]), Is.False);
}
);
TestDbProvider.SetupAlterAndVerify(
setup: db => {
db.ExemptsLogging.Add(new ExemptedLoggingEntity {
GuildId = MockData.Ids[0], Id = MockData.Ids[0], Type = ExemptedEntityType.Channel
});
db.ExemptsLogging.Add(new ExemptedLoggingEntity {
GuildId = MockData.Ids[1], Id = MockData.Ids[0], Type = ExemptedEntityType.Role
});
db.ExemptsLogging.Add(new ExemptedLoggingEntity {
GuildId = MockData.Ids[2], Id = MockData.Ids[1], Type = ExemptedEntityType.Member
});
},
alter: db => this.Service.LoadData(),
verify: db => {
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[0], cid: MockData.Ids[0]), Is.True);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[1], cid: MockData.Ids[0]), Is.False);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[2], cid: MockData.Ids[1]), Is.False);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[3], cid: MockData.Ids[2]), Is.False);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[0], cid: MockData.Ids[1]), Is.False);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[1], cid: MockData.Ids[1]), Is.False);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[2], cid: MockData.Ids[2]), Is.False);
Assert.That(this.Service.IsChannelExempted(gid: MockData.Ids[3], cid: MockData.Ids[3]), Is.False);
}
);
}
public void TextContainsFilterTests()
{
TestDbProvider.Verify(db => Assert.That(this.Service.TextContainsFilter(MockData.Ids[0], "cat", out _), Is.False));
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockFilters(db),
alter: db => this.Service.LoadData(),
verify: db => {
ContainsFilter(MockData.Ids[0], "cat", true);
ContainsFilter(MockData.Ids[0], "doG.", true);
ContainsFilter(MockData.Ids[0], "what a nice Cat, indeed.", true);
ContainsFilter(MockData.Ids[0], "a fiSh?? and a cAt???", true);
ContainsFilter(MockData.Ids[0], "i can haz spaces :)", true);
ContainsFilter(MockData.Ids[0], "what a cute doge!", true);
ContainsFilter(MockData.Ids[0], "doggy dooby doo", true);
ContainsFilter(MockData.Ids[0], "fapfapfapfap", true);
ContainsFilter(MockData.Ids[1], "cat", true);
ContainsFilter(MockData.Ids[1], "*****@*****.**", true);
ContainsFilter(MockData.Ids[1], "a nice Doge", true);
ContainsFilter(MockData.Ids[1], "whyyyYyyyyyyyy", true);
ContainsFilter(MockData.Ids[2], "[email protected]!", true);
ContainsFilter(MockData.Ids[2], "help.me.pls.dot.com?abc", true);
ContainsFilter(MockData.Ids[2], "no-way i will do that!", true);
ContainsFilter(MockData.Ids[2], "spam @every1", true);
ContainsFilter(MockData.Ids[0], "caat", false);
ContainsFilter(MockData.Ids[0], "c4tz", false);
ContainsFilter(MockData.Ids[0], "i like c@t.", false);
ContainsFilter(MockData.Ids[0], "i like d0ges.", false);
ContainsFilter(MockData.Ids[0], "so fisshy...", false);
ContainsFilter(MockData.Ids[0], "dooggggy", false);
ContainsFilter(MockData.Ids[1], "whhy", false);
ContainsFilter(MockData.Ids[2], "[email protected]=com!", false);
ContainsFilter(MockData.Ids[2], "help.me.pls.dot&com?abc", false);
ContainsFilter(MockData.Ids[2], "no--way i will do that!", false);
ContainsFilter(MockData.Ids[2], "spam every1", false);
}
);
void ContainsFilter(ulong gid, string text, bool filtered)
{
Assert.That(this.Service.TextContainsFilter(gid, text, out Filter? filter), Is.EqualTo(filtered));
if (filtered)
{
Assert.That(filter, Is.Not.Null);
Assert.That(filter !.Regex.IsMatch(text));
}
else
{
Assert.That(filter, Is.Null);
}
}
}
public void GetCachedConfigTests()
{
TestDbProvider.SetupAlterAndVerify(
setup: db => this.SetMockGuildConfig(db),
alter: db => this.Service.LoadData(),
verify: db => {
Assert.That(HaveSamePropertyValues(this.Service.GetCachedConfig(1), new CachedGuildConfig()));
Assert.That(HaveSamePropertyValues(this.gcfg[MockData.Ids[0]].CachedConfig, this.Service.GetCachedConfig(MockData.Ids[0])));
Assert.That(HaveSamePropertyValues(this.gcfg[MockData.Ids[1]].CachedConfig, this.Service.GetCachedConfig(MockData.Ids[1])));
}
);
}
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 void GetGuildPrefixTests()
{
string defPrefix = new BotConfig().Prefix;
TestDbProvider.SetupAlterAndVerify(
setup: db => this.SetMockGuildConfig(db),
alter: db => this.Service.LoadData(),
verify: db => {
Assert.That(this.Service.GetGuildPrefix(MockData.Ids[0]), Is.EqualTo(this.gcfg[MockData.Ids[0]].Prefix));
Assert.That(this.Service.GetGuildPrefix(MockData.Ids[1]), Is.EqualTo(defPrefix));
Assert.That(this.Service.GetGuildPrefix(MockData.Ids[2]), Is.EqualTo(defPrefix));
Assert.That(this.Service.GetGuildPrefix(1), Is.EqualTo(defPrefix));
}
);
}
public void GetCommandUsageExamplesTests()
{
TestDbProvider.SetupAlterAndVerify(
setup: db => {
GuildConfig gcfg = db.Configs.Find((long)MockData.Ids[0]);
gcfg.Locale = this.EnLocale;
db.Configs.Update(gcfg);
},
alter: db => {
this.Configs.LoadData();
this.Localization.LoadData(this.ValidTestDataPath);
this.Service.LoadData(this.ValidTestDataPath);
},
verify: db => {
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[0], "cmd1"), Is.EqualTo(new[] { "!cmd1", "!cmd1 @User" }));
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[0], "cmd2"), Is.EqualTo(new[] { "!cmd2", "!cmd2 @Member Reason reason" }));
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[0], "cmd1 subcommand"), Is.EqualTo(new[] { "!cmd1 subcommand", "!cmd1 subcommand @User" }));
Assert.That(() => this.Service.GetCommandUsageExamples(MockData.Ids[0], "does not exist"), Throws.InstanceOf <KeyNotFoundException>());
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[1], "cmd1"), Is.EqualTo(new[] { "!cmd1", "!cmd1 @User" }));
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[1], "cmd2"), Is.EqualTo(new[] { "!cmd2", "!cmd2 @Member Reason reason" }));
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[1], "cmd1 subcommand"), Is.EqualTo(new[] { "!cmd1 subcommand", "!cmd1 subcommand @User" }));
Assert.That(() => this.Service.GetCommandUsageExamples(MockData.Ids[1], "does not exist"), Throws.InstanceOf <KeyNotFoundException>());
}
);
TestDbProvider.SetupAlterAndVerify(
setup: db => {
GuildConfig gcfg = db.Configs.Find((long)MockData.Ids[1]);
gcfg.Locale = this.SrLocale;
db.Configs.Update(gcfg);
},
alter: db => {
this.Configs.LoadData();
this.Localization.LoadData(this.ValidTestDataPath);
this.Service.LoadData(this.ValidTestDataPath);
},
verify: db => {
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[0], "cmd1"), Is.EqualTo(new[] { "!cmd1", "!cmd1 @User" }));
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[0], "cmd2"), Is.EqualTo(new[] { "!cmd2", "!cmd2 @Member Reason reason" }));
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[0], "cmd1 subcommand"), Is.EqualTo(new[] { "!cmd1 subcommand", "!cmd1 subcommand @User" }));
Assert.That(() => this.Service.GetCommandUsageExamples(MockData.Ids[0], "does not exist"), Throws.InstanceOf <KeyNotFoundException>());
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[1], "cmd1"), Is.EqualTo(new[] { "!cmd1", "!cmd1 @Korisnik" }));
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[1], "cmd2"), Is.EqualTo(new[] { "!cmd2", "!cmd2 @Clan Razlog razlog" }));
Assert.That(this.Service.GetCommandUsageExamples(MockData.Ids[1], "cmd1 subcommand"), Is.EqualTo(new[] { "!cmd1 subcommand", "!cmd1 subcommand @Korisnik" }));
Assert.That(() => this.Service.GetCommandUsageExamples(MockData.Ids[1], "does not exist"), Throws.InstanceOf <KeyNotFoundException>());
}
);
}
public void GetGuildTextReactionsTests()
{
Assert.That(this.Service.GetGuildTextReactions(MockData.Ids[0]), Is.Empty);
TestDbProvider.AlterAndVerify(
alter: db => this.Service.LoadData(),
verify: db => {
for (int i = 0; i < MockData.Ids.Count; i++)
{
AssertGuildReactionCount(i, 0);
}
}
);
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockReactions(db),
alter: db => {
this.UpdateTextReactionCount(db);
this.Service.LoadData();
},
verify: db => {
for (int i = 0; i < MockData.Ids.Count; i++)
{
AssertGuildReactionCount(i, this.trCount[i]);
}
IReadOnlyCollection <TextReaction> trs = this.Service.GetGuildTextReactions(MockData.Ids[1]);
Assert.That(trs.Single(tr => tr.Response == "response12" && tr.Triggers.Single() == "y u do dis"), Is.Not.Null);
Assert.That(trs.Single(tr => tr.Response == "response23" && tr.Triggers.Single() == "rick"), Is.Not.Null);
Assert.That(trs.Single(tr => tr.Response == "response34" && tr.Triggers.Single() == "astley"), Is.Not.Null);
}
);
void AssertGuildReactionCount(int id, int count)
{
IReadOnlyCollection <TextReaction> trs = this.Service.GetGuildTextReactions(MockData.Ids[id]);
Assert.That(trs, Has.Exactly(count).Items);
Assert.That(trs.Select(tr => tr.Id), Is.Unique);
foreach (IEnumerable <string> triggers in trs.Select(tr => tr.Triggers))
{
Assert.That(triggers, Is.Not.Empty);
}
}
}
public void GetGuildEmojiReactionsTests()
{
Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[0]), Is.Empty);
TestDbProvider.AlterAndVerify(
alter: db => this.Service.LoadData(),
verify: db => {
for (int i = 0; i < MockData.Ids.Count; i++)
{
AssertGuildReactionCount(i, 0);
}
}
);
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockReactions(db),
alter: db => {
this.UpdateEmojiReactionCount(db);
this.Service.LoadData();
},
verify: db => {
for (int i = 0; i < MockData.Ids.Count; i++)
{
AssertGuildReactionCount(i, this.erCount[i]);
}
IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[1]);
Assert.That(ers.Single(er => er.Response == Emojis.Cake.GetDiscordName() && er.Triggers.Single() == "abc"), Is.Not.Null);
Assert.That(ers.Single(er => er.Response == Emojis.ArrowUp.GetDiscordName() && er.Triggers.Single() == "abc"), Is.Not.Null);
Assert.That(ers.Single(er => er.Response == Emojis.ArrowDown.GetDiscordName() && er.Triggers.Single() == "abc"), Is.Not.Null);
}
);
void AssertGuildReactionCount(int id, int count)
{
IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[id]);
Assert.That(ers, Has.Exactly(count).Items);
Assert.That(ers.Select(er => er.Id), Is.Unique);
foreach (IEnumerable <string> triggers in ers.Select(er => er.Triggers))
{
Assert.That(triggers, Is.Not.Empty);
}
}
}
public void GetTests()
{
TestDbProvider.AlterAndVerify(
alter: _ => { },
verify: db => {
IReadOnlyList <ulong> all = this.Service.GetIds();
Assert.That(all, Is.Empty);
}
);
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockData(db),
alter: _ => { },
verify: db => {
IReadOnlyList <ulong> all = this.Service.GetIds();
Assert.That(all, Is.EqualTo(new[] { MockData.Ids[0], MockData.Ids[1] }));
}
);
}
public void GetGuildLocaleTests()
{
TestDbProvider.SetupAlterAndVerify(
setup: db => {
GuildConfig gcfg = db.Configs.Find((long)MockData.Ids[1]);
gcfg.Locale = this.SrLocale;
db.Configs.Update(gcfg);
},
alter: db => {
this.Configs.LoadData();
this.Service.LoadData(this.ValidTestDataPath);
},
verify: db => {
Assert.That(this.Service.GetGuildLocale(MockData.Ids[0]), Is.EqualTo(this.EnLocale));
Assert.That(this.Service.GetGuildLocale(MockData.Ids[1]), Is.EqualTo(this.SrLocale));
Assert.That(this.Service.GetGuildLocale(1), Is.EqualTo(this.EnLocale));
}
);
}
public void GetGuildFiltersTests()
{
foreach (ulong id in MockData.Ids)
{
Assert.That(this.Service.GetGuildFilters(id), Is.Empty);
}
TestDbProvider.AlterAndVerify(
alter: db => this.Service.LoadData(),
verify: db => {
for (int i = 0; i < MockData.Ids.Count; i++)
{
this.AssertGuildFilterCount(db, i, 0);
}
}
);
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockFilters(db),
alter: db => this.Service.LoadData(),
verify: db => {
this.AssertGuildFilterCount(db, 0, 5);
this.AssertGuildFilterCount(db, 1, 3);
this.AssertGuildFilterCount(db, 2, 3);
this.AssertGuildFilterCount(db, 3, 0);
this.AssertSingleAndTest(db, 0, regex: "fish", match: true, "fish", "this is just a fish", "my name is mr.Fishy, and I swim.");
this.AssertSingleAndTest(db, 0, regex: "fish", match: false, "fi sh", "f1sh");
this.AssertSingleAndTest(db, 0, regex: "dog(e|gy)?", match: true, "doge", "what a cute doggy you have", "your DoGs bite?");
this.AssertSingleAndTest(db, 0, regex: "dog(e|gy)?", match: false, "does your D0Gge bite?");
this.AssertSingleAndTest(db, 1, regex: "cat", match: true, "cat", "a CaT abc", "play with my Cat.", "cat-dog");
this.AssertSingleAndTest(db, 1, regex: "cat", match: false, "do you have any c@ts");
this.AssertSingleAndTest(db, 2, regex: "no-way", match: true, "no-way", "there can be No-way!", "oh no-way-!");
this.AssertSingleAndTest(db, 2, regex: "no-way", match: false, "nope-way", "no way");
this.AssertSingleAndTest(db, 2, regex: @"dot\.com", match: true, "*****@*****.**", "dot.dot.coms", "dot.com.com", "dot-me-dot.com");
this.AssertSingleAndTest(db, 2, regex: @"dot\.com", match: false, "dot-com");
}
);
}
public void FindMatchingEmojiReactionsTests()
{
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockReactions(db),
alter: db => this.Service.LoadData(),
verify: db => {
AssertFindReactionsCount(0, "HAHAHA", 0);
AssertFindReactionsCount(0, "abbbbbbbbbbbbbc", 1);
AssertFindReactionsCount(0, "This is not a test.", 1);
AssertFindReactionsCount(0, "Ha abc ha", 4);
AssertFindReactionsCount(0, "This cde has only one", 1);
AssertFindReactionsCount(1, "abbcdef doesnt work", 0);
AssertFindReactionsCount(1, "But @abc works", 3);
AssertFindReactionsCount(1, "So does @ABC.", 3);
AssertFindReactionsCount(2, "This one doesn't have reactions...", 0);
}
);
void AssertFindReactionsCount(int id, string text, int count)
{
IReadOnlyCollection <EmojiReaction> ers = this.Service.FindMatchingEmojiReactions(MockData.Ids[id], text);
Assert.That(ers, Has.Exactly(count).Items);
foreach (EmojiReaction er in ers)
{
Assert.That(er.IsMatch(text));
}
IReadOnlyCollection <EmojiReaction> all = this.Service.GetGuildEmojiReactions(MockData.Ids[id]);
Assert.That(ers, Is.SubsetOf(all));
foreach (EmojiReaction er in all.Except(ers))
{
Assert.That(er.IsMatch(text), Is.False);
}
}
}
public void GetStringTests()
{
TestDbProvider.SetupAlterAndVerify(
setup: db => {
GuildConfig gcfg = db.Configs.Find((long)MockData.Ids[1]);
gcfg.Locale = this.SrLocale;
db.Configs.Update(gcfg);
},
alter: db => {
this.Configs.LoadData();
this.Service.LoadData(this.ValidTestDataPath);
},
verify: db => {
Assert.That(this.Service.GetString(MockData.Ids[0], "suc"), Is.EqualTo("Success!"));
Assert.That(this.Service.GetString(MockData.Ids[0], "err"), Is.EqualTo("Error!"));
Assert.That(this.Service.GetString(MockData.Ids[1], "suc"), Is.EqualTo("Uspeh!"));
Assert.That(this.Service.GetString(MockData.Ids[1], "err"), Is.EqualTo("Greska!"));
Assert.That(this.Service.GetString(123, "err"), Is.EqualTo("Error!"));
Assert.That(() => this.Service.GetString(MockData.Ids[0], "does not exist"), Throws.InstanceOf <LocalizationException>());
}
);
// TODO test with args
}
public void FindMatchingTextReactionsTests()
{
TestDbProvider.SetupAlterAndVerify(
setup: db => this.AddMockReactions(db),
alter: db => this.Service.LoadData(),
verify: db => {
AssertFindReaction(0, "HAHAHA", false);
AssertFindReaction(0, "This is not a test.", true);
AssertFindReaction(0, "Ha abc ha", true);
AssertFindReaction(0, "This trigger me has only one", true);
AssertFindReaction(1, "ricckasstley doesnt work", false);
AssertFindReaction(1, "But @rick- works", true);
AssertFindReaction(1, "So does -RIcK.", true);
AssertFindReaction(2, "This one doesn't have reactions...", false);
AssertFindReaction(3, "Multiple valid reactions teSt.", true);
AssertFindReaction(3, "But teSting has only one", true);
AssertFindReaction(3, "But t3stings doesn't match", false);
}
);
void AssertFindReaction(int id, string text, bool exists)
{
TextReaction?tr = this.Service.FindMatchingTextReaction(MockData.Ids[id], text);
if (exists)
{
Assert.That(tr, Is.Not.Null);
Assert.That(tr !.IsMatch(text));
}
else
{
Assert.That(tr, Is.Null);
}
}
}
