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 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 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 async Task ClearAsyncTests()
{
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : db => this.Service.ClearAsync(),
verify : db => {
IReadOnlyList <ulong> all = this.Service.GetIds();
Assert.That(all, Is.Empty);
Assert.That(db.PrivilegedUsers, Is.Empty);
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => Task.CompletedTask,
alter : db => this.Service.ClearAsync(),
verify : db => {
IReadOnlyList <ulong> all = this.Service.GetIds();
Assert.That(all, Is.Empty);
Assert.That(db.PrivilegedUsers, Is.Empty);
return(Task.CompletedTask);
}
);
}
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 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 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 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 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 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 async Task GetBlockedAsyncTests()
{
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : db => {
this.Service.LoadData();
return(Task.CompletedTask);
},
verify : async db => {
ulong[] bcExpected = new[] { MockData.Ids[0], MockData.Ids[1], MockData.Ids[2] };
ulong[] buExpected = new[] { MockData.Ids[0], MockData.Ids[4], MockData.Ids[5] };
Assert.That(this.Service.BlockedChannels, Is.EquivalentTo(bcExpected));
Assert.That(this.Service.BlockedUsers, Is.EquivalentTo(buExpected));
IReadOnlyList <BlockedChannel> bchns = await this.Service.GetBlockedChannelsAsync();
IReadOnlyList <BlockedUser> busrs = await this.Service.GetBlockedUsersAsync();
Assert.That(bchns.Select(c => c.Id), Is.EquivalentTo(bcExpected));
Assert.That(busrs.Select(u => u.Id), Is.EquivalentTo(buExpected));
Assert.That(bchns.Select(c => c.Reason), Is.EquivalentTo(new[] { "chn 1", "chn 1", "chn 2" }));
Assert.That(busrs.Select(u => u.Reason), Is.EquivalentTo(new[] { "usr 1", "usr 1", "usr 2" }));
}
);
}
public async Task FilledDatabaseSyncTests()
{
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
db.XpCounts.AddRange(new[] {
new XpCount {
Xp = 5,
GuildId = MockData.Ids[0],
UserId = MockData.Ids[0]
},
new XpCount {
Xp = 5,
GuildId = MockData.Ids[0],
UserId = MockData.Ids[1]
},
new XpCount {
Xp = 1,
GuildId = MockData.Ids[1],
UserId = MockData.Ids[1]
},
});
db.SaveChanges();
this.Service.LoadData();
return(Task.CompletedTask);
},
alter : db => {
this.Service.ChangeXp(MockData.Ids[0], MockData.Ids[1]);
this.Service.ChangeXp(MockData.Ids[1], MockData.Ids[1]);
this.Service.ChangeXp(MockData.Ids[2], MockData.Ids[1]);
this.Service.ChangeXp(MockData.Ids[0], MockData.Ids[2]);
return(this.Service.Sync());
},
verify : db => {
Assert.That(db.XpCounts, Has.Exactly(5).Items);
XpCount u00 = db.XpCounts.Find((long)MockData.Ids[0], (long)MockData.Ids[0]);
XpCount u01 = db.XpCounts.Find((long)MockData.Ids[0], (long)MockData.Ids[1]);
XpCount u11 = db.XpCounts.Find((long)MockData.Ids[1], (long)MockData.Ids[1]);
XpCount u21 = db.XpCounts.Find((long)MockData.Ids[2], (long)MockData.Ids[1]);
XpCount u02 = 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(u00, Is.Not.Null);
Assert.That(u01, Is.Not.Null);
Assert.That(u11, Is.Not.Null);
Assert.That(u21, Is.Not.Null);
Assert.That(u02, Is.Not.Null);
Assert.That(u00.Xp, Is.EqualTo(5));
Assert.That(u01.Xp, Is.EqualTo(6));
Assert.That(u11.Xp, Is.EqualTo(2));
Assert.That(u21.Xp, Is.EqualTo(1));
Assert.That(u02.Xp, Is.EqualTo(1));
Assert.That(this.Service.GetUserXp(MockData.Ids[0], MockData.Ids[0]), Is.EqualTo(5));
Assert.That(this.Service.GetUserXp(MockData.Ids[0], MockData.Ids[1]), Is.EqualTo(6));
Assert.That(this.Service.GetUserXp(MockData.Ids[1], MockData.Ids[1]), Is.EqualTo(2));
Assert.That(this.Service.GetUserXp(MockData.Ids[2], MockData.Ids[1]), Is.EqualTo(1));
Assert.That(this.Service.GetUserXp(MockData.Ids[0], MockData.Ids[2]), Is.EqualTo(1));
return(Task.CompletedTask);
}
);
}
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 TestDapperPlus()
{
var opts = Options.Create(new TestConnectionOptions
{
Test = TestDataConnection.TestConnecttion
});
var provider = new TestDbProvider(opts);
_userRepo = new TestUserDapperPlusRepository(provider);
_userMessageRepo = new TestUserMesasgeDapperPlusRepository(provider);
}
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 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 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 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 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 async Task ClearAsyncTests()
{
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : db => this.Service.ClearAsync(MockData.Ids[0]),
verify : db => {
IReadOnlyList <ulong> all = this.Service.GetIds(MockData.Ids[0]);
Assert.That(all, Is.Empty);
Assert.That(this.Service.GroupSelector(db.AutoRoles, MockData.Ids[0]), Is.Empty);
IReadOnlyList <ulong> gid1 = this.Service.GetIds(MockData.Ids[1]);
Assert.That(gid1, Is.EqualTo(new[] { MockData.Ids[2] }));
Assert.That(this.GetGuildRoles(db, MockData.Ids[1]), Is.EquivalentTo(new[] { MockData.Ids[2] }));
return(Task.CompletedTask);
}
);
int bef = 0;
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async db => {
bef = db.AutoRoles.Count();
await this.Service.ClearAsync(MockData.Ids[3]);
},
verify : db => {
Assert.That(db.AutoRoles, Has.Exactly(bef).Items);
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => Task.CompletedTask,
alter : db => this.Service.ClearAsync(MockData.Ids[0]),
verify : db => {
foreach (ulong id in MockData.Ids)
{
IReadOnlyList <ulong> all = this.Service.GetIds(id);
Assert.That(all, Is.Empty);
}
return(Task.CompletedTask);
}
);
}
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 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 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 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 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");
}
);
}
public async Task RemoveAllEmojiReactionsTests()
{
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[1]), Is.EqualTo(3));
Assert.That(await this.Service.RemoveEmojiReactionsAsync(MockData.Ids[1]), Is.EqualTo(0));
},
verify : db => {
Assert.That(db.EmojiReactions, Has.Exactly(this.erCount.Sum(kvp => kvp.Value) - 3).Items);
Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[0]), Has.Exactly(this.erCount[0]).Items);
Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[1]), Is.Empty);
Assert.That(db.EmojiReactions.Select(tr => tr.GuildId), Does.Not.Contain(MockData.Ids[1]));
return(Task.CompletedTask);
}
);
}
