public void GetRulesTests()
{
TestDbProvider.Verify(
verify: db => {
foreach (ulong gid in MockData.Ids)
{
Assert.That(this.Service.GetRules(gid), Is.Empty);
}
}
);
TestDbProvider.SetupAndVerify(
setup: db => this.AddMockRules(db),
verify: db => {
Assert.That(this.Service.GetRules(MockData.Ids[0]), Has.Exactly(11).Items);
Assert.That(this.Service.GetRules(MockData.Ids[0], "a"), Has.Exactly(2).Items);
Assert.That(this.Service.GetRules(MockData.Ids[0], "b"), Has.Exactly(1).Items);
Assert.That(this.Service.GetRules(MockData.Ids[0], "f"), Has.Exactly(2).Items);
Assert.That(this.Service.GetRules(MockData.Ids[0], "f g"), Has.Exactly(2).Items);
Assert.That(this.Service.GetRules(MockData.Ids[0], "aaa"), Is.Empty);
Assert.That(this.Service.GetRules(MockData.Ids[0], "x"), Is.Empty);
Assert.That(this.Service.GetRules(MockData.Ids[1]), Has.Exactly(22).Items);
Assert.That(this.Service.GetRules(MockData.Ids[1], "a"), Has.Exactly(2).Items);
Assert.That(this.Service.GetRules(MockData.Ids[1], "a b"), Has.Exactly(3).Items);
Assert.That(this.Service.GetRules(MockData.Ids[1], "aaa"), Is.Empty);
Assert.That(this.Service.GetRules(MockData.Ids[1], "g"), Has.Exactly(2).Items);
Assert.That(this.Service.GetRules(MockData.Ids[1], "g h"), Has.Exactly(3).Items);
Assert.That(this.Service.GetRules(MockData.Ids[1], "g h j"), Has.Exactly(4).Items);
Assert.That(this.Service.GetRules(MockData.Ids[3]), Is.Empty);
Assert.That(this.Service.GetRules(MockData.Ids[3], "x"), Is.Empty);
}
);
}
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 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 TextContainsForbiddenNameTests()
{
TestDbProvider.Verify(db => Assert.That(this.Service.IsNameForbidden(MockData.Ids[0], "cat", out _), Is.False));
TestDbProvider.SetupAndVerify(
setup: db => this.AddMockForbiddenNames(db),
verify: db => {
IsForbidden(MockData.Ids[0], "cat", true);
IsForbidden(MockData.Ids[0], "doG.", true);
IsForbidden(MockData.Ids[0], "what a nice Cat, indeed.", true);
IsForbidden(MockData.Ids[0], "a fiSh?? and a cAt???", true);
IsForbidden(MockData.Ids[0], "i can haz spaces :)", true);
IsForbidden(MockData.Ids[0], "what a cute doge!", true);
IsForbidden(MockData.Ids[0], "doggy dooby doo", true);
IsForbidden(MockData.Ids[0], "fapfapfapfap", true);
IsForbidden(MockData.Ids[1], "cat", true);
IsForbidden(MockData.Ids[1], "*****@*****.**", true);
IsForbidden(MockData.Ids[1], "a nice Doge", true);
IsForbidden(MockData.Ids[1], "whyyyYyyyyyyyy", true);
IsForbidden(MockData.Ids[2], "[email protected]!", true);
IsForbidden(MockData.Ids[2], "help.me.pls.dot.com?abc", true);
IsForbidden(MockData.Ids[2], "no-way i will do that!", true);
IsForbidden(MockData.Ids[2], "spam @every1", true);
IsForbidden(MockData.Ids[0], "caat", false);
IsForbidden(MockData.Ids[0], "c4tz", false);
IsForbidden(MockData.Ids[0], "i like c@t.", false);
IsForbidden(MockData.Ids[0], "i like d0ges.", false);
IsForbidden(MockData.Ids[0], "so fisshy...", false);
IsForbidden(MockData.Ids[0], "dooggggy", false);
IsForbidden(MockData.Ids[1], "whhy", false);
IsForbidden(MockData.Ids[2], "[email protected]=com!", false);
IsForbidden(MockData.Ids[2], "help.me.pls.dot&com?abc", false);
IsForbidden(MockData.Ids[2], "no--way i will do that!", false);
IsForbidden(MockData.Ids[2], "spam every1", false);
}
);
void IsForbidden(ulong gid, string name, bool forbidden)
{
Assert.That(this.Service.IsNameForbidden(gid, name, out ForbiddenName? fname), Is.EqualTo(forbidden));
if (forbidden)
{
Assert.That(fname, Is.Not.Null);
Assert.That(fname !.Regex.IsMatch(name));
}
else
{
Assert.That(fname, Is.Null);
}
}
}
public void IsBlockedTests()
{
TestDbProvider.Verify(
verify: db => {
foreach (ulong gid in MockData.Ids)
{
foreach (ulong id in MockData.Ids)
{
Assert.That(this.Service.IsBlocked("a", gid, id, null), Is.False);
Assert.That(this.Service.IsBlocked("a", gid, id, MockData.Ids[0]), Is.False);
}
}
}
);
TestDbProvider.SetupAndVerify(
setup: db => this.AddMockRules(db),
verify: db => {
this.AssertIsBlocked(MockData.Ids[0], "a", blocked: new[] { MockData.Ids[0], MockData.Ids[2] });
this.AssertIsBlocked(MockData.Ids[0], "b", blocked: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[0], "c", allowed: new[] { MockData.Ids[0] });
this.AssertIsBlocked(MockData.Ids[0], "d", blocked: new[] { MockData.Ids[1] });
this.AssertIsBlocked(MockData.Ids[0], "e", allowed: new[] { MockData.Ids[1] });
this.AssertIsBlocked(MockData.Ids[0], "f", allowed: new[] { MockData.Ids[3] }, blocked: new[] { MockData.Ids[1] });
this.AssertIsBlocked(MockData.Ids[0], "x", allowed: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[1], "a", blocked: new[] { MockData.Ids[0], MockData.Ids[2] });
this.AssertIsBlocked(MockData.Ids[1], "a b", blocked: new[] { MockData.Ids[0] });
this.AssertIsBlocked(MockData.Ids[1], "b", blocked: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[1], "b a", allowed: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[1], "b a c", blocked: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[1], "c", allowed: new[] { MockData.Ids[0] });
this.AssertIsBlocked(MockData.Ids[1], "c d", blocked: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[1], "d", blocked: new[] { MockData.Ids[1] });
this.AssertIsBlocked(MockData.Ids[1], "d e", allowed: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[1], "e", allowed: new[] { MockData.Ids[1] });
this.AssertIsBlocked(MockData.Ids[1], "e f", blocked: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[1], "f", allowed: new[] { MockData.Ids[3] }, blocked: new[] { MockData.Ids[1] });
this.AssertIsBlocked(MockData.Ids[1], "f g", blocked: new[] { MockData.Ids[1], MockData.Ids[3] });
this.AssertIsBlocked(MockData.Ids[1], "g", allowed: new[] { MockData.Ids[1] });
this.AssertIsBlocked(MockData.Ids[1], "g h", allowed: new[] { MockData.Ids[1] });
this.AssertIsBlocked(MockData.Ids[1], "g h j", allowed: new[] { MockData.Ids[1], MockData.Ids[3] });
this.AssertIsBlocked(MockData.Ids[1], "x", allowed: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[2], "a", blocked: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[2], "aaa", blocked: new[] { MockData.Ids[1] });
this.AssertIsBlocked(MockData.Ids[2], "x", allowed: MockData.Ids);
this.AssertIsBlocked(MockData.Ids[3], "x", allowed: MockData.Ids);
}
);
}
public void GetGuildForbiddenNamesTests()
{
TestDbProvider.Verify(
db => {
foreach (ulong id in MockData.Ids)
{
Assert.That(this.Service.GetGuildForbiddenNames(id), Is.Empty);
}
}
);
TestDbProvider.Verify(
db => {
for (int i = 0; i < MockData.Ids.Count; i++)
{
this.AssertGuildForbiddenNameCount(db, i, 0);
}
}
);
TestDbProvider.SetupAndVerify(
setup: db => this.AddMockForbiddenNames(db),
verify: db => {
this.AssertGuildForbiddenNameCount(db, 0, 5);
this.AssertGuildForbiddenNameCount(db, 1, 3);
this.AssertGuildForbiddenNameCount(db, 2, 3);
this.AssertGuildForbiddenNameCount(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");
}
);
}
