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 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 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 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 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 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 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 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);
}
);
}
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 GetConfigAsyncTests()
{
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.SetMockGuildConfig(db);
return(Task.CompletedTask);
},
alter : db => {
this.Service.LoadData();
return(Task.CompletedTask);
},
verify : async db => {
Assert.That(HaveSamePropertyValues(
this.gcfg[MockData.Ids[0]].CachedConfig,
(await this.Service.GetConfigAsync(MockData.Ids[0])).CachedConfig
));
Assert.That(HaveSamePropertyValues(
this.gcfg[MockData.Ids[1]].CachedConfig,
(await this.Service.GetConfigAsync(MockData.Ids[1])).CachedConfig
));
Assert.That(await this.Service.GetConfigAsync(1), Is.Not.Null);
}
);
}
public async Task RemoveAsyncTests()
{
int bef = 0;
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async _ => Assert.That(await this.Service.RemoveAsync(MockData.Ids[0], MockData.Ids.Take(2)), Is.EqualTo(2)),
verify : db => {
Assert.That(this.Service.GetIds(MockData.Ids[0]), Is.Empty);
Assert.That(this.Service.GetIds(MockData.Ids[1]).Single(), Is.EqualTo(MockData.Ids[2]));
Assert.That(this.GetGuildRoles(db, MockData.Ids[0]), Is.Empty);
Assert.That(this.GetGuildRoles(db, MockData.Ids[1]), Is.Not.Empty);
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async _ => Assert.That(await this.Service.RemoveAsync(MockData.Ids[0], MockData.Ids[1]), Is.EqualTo(1)),
verify : db => {
Assert.That(this.Service.GetIds(MockData.Ids[0]).Single(), Is.EqualTo(MockData.Ids[0]));
Assert.That(this.GetGuildRoles(db, MockData.Ids[0]).Single(), Is.EqualTo(MockData.Ids[0]));
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async _ => Assert.That(await this.Service.RemoveAsync(MockData.Ids[0], MockData.Ids[1], MockData.Ids[1], MockData.Ids[1]), Is.EqualTo(1)),
verify : db => {
Assert.That(this.Service.GetIds(MockData.Ids[0]).Single(), Is.EqualTo(MockData.Ids[0]));
Assert.That(this.GetGuildRoles(db, MockData.Ids[0]).Single(), Is.EqualTo(MockData.Ids[0]));
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async db => {
Assert.That(await this.Service.RemoveAsync(MockData.Ids[0], MockData.Ids[3], MockData.Ids[4]), Is.Zero);
bef = db.AutoRoles.Count();
},
verify : db => {
Assert.That(this.GetGuildRoles(db, MockData.Ids[0]), Is.EquivalentTo(MockData.Ids.Take(2)));
Assert.That(db.AutoRoles, Has.Exactly(bef).Items);
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async db => {
bef = db.AutoRoles.Count();
foreach (ulong gid in MockData.Ids)
{
Assert.That(await this.Service.RemoveAsync(gid), Is.Zero);
Assert.That(await this.Service.RemoveAsync(gid, null !), Is.Zero);
Assert.That(await this.Service.RemoveAsync(gid, Array.Empty <ulong>()), Is.Zero);
Assert.That(await this.Service.RemoveAsync(gid, Enumerable.Empty <ulong>()), Is.Zero);
}
},
verify : db => {
Assert.That(this.Service.GetIds(MockData.Ids[0]), Is.EquivalentTo(MockData.Ids.Take(2)));
Assert.That(db.AutoRoles, Has.Exactly(bef).Items);
return(Task.CompletedTask);
}
);
}
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 UnblockAsyncTests()
{
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async db => {
this.Service.Sync();
Assert.That(await this.Service.UnblockChannelAsync(MockData.Ids[1]), Is.True);
Assert.That(await this.Service.UnblockChannelAsync(MockData.Ids[2]), Is.True);
Assert.That(await this.Service.UnblockUserAsync(MockData.Ids[4]), Is.True);
Assert.That(await this.Service.UnblockUserAsync(MockData.Ids[5]), Is.True);
},
verify : async db => {
await this.AssertBlockedAsync(db,
bcExpected: new[] { MockData.Ids[0] },
buExpected: new[] { MockData.Ids[0] },
bcReasons: new[] { "chn 1" },
buReasons: new[] { "usr 1" }
);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async db => {
this.Service.Sync();
Assert.That(await this.Service.UnblockChannelAsync(MockData.Ids[0]), Is.True);
Assert.That(await this.Service.UnblockChannelAsync(MockData.Ids[3]), Is.False);
Assert.That(await this.Service.UnblockUserAsync(MockData.Ids[0]), Is.True);
Assert.That(await this.Service.UnblockUserAsync(MockData.Ids[1]), Is.False);
},
verify : db => this.AssertBlockedAsync(db,
bcExpected: new[] { MockData.Ids[1], MockData.Ids[2] },
buExpected: new[] { MockData.Ids[4], MockData.Ids[5] },
bcReasons: new[] { "chn 1", "chn 2" },
buReasons: new[] { "usr 1", "usr 2" }
)
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async db => {
this.Service.Sync();
Assert.That(await this.Service.UnblockChannelsAsync(new[] { MockData.Ids[0], MockData.Ids[1] }), Is.EqualTo(2));
Assert.That(await this.Service.UnblockUsersAsync(new[] { MockData.Ids[4], MockData.Ids[5] }), Is.EqualTo(2));
},
verify : db => this.AssertBlockedAsync(db,
bcExpected: new[] { MockData.Ids[2] },
buExpected: new[] { MockData.Ids[0] },
bcReasons: new[] { "chn 2" },
buReasons: new[] { "usr 1" }
)
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async db => {
this.Service.Sync();
Assert.That(await this.Service.UnblockChannelsAsync(new[] { MockData.Ids[0], MockData.Ids[0] }), Is.EqualTo(1));
Assert.That(await this.Service.UnblockUsersAsync(new[] { MockData.Ids[1], MockData.Ids[1] }), Is.Zero);
},
verify : db => this.AssertBlockedAsync(db,
new[] { MockData.Ids[1], MockData.Ids[2] },
new[] { MockData.Ids[0], MockData.Ids[4], MockData.Ids[5] },
new[] { "chn 1", "chn 2" },
new[] { "usr 1", "usr 1", "usr 2" }
)
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async db => {
this.Service.Sync();
Assert.That(await this.Service.UnblockChannelAsync(MockData.Ids[0]), Is.True);
Assert.That(await this.Service.UnblockChannelAsync(MockData.Ids[0]), Is.False);
Assert.That(await this.Service.UnblockUserAsync(MockData.Ids[0]), Is.True);
Assert.That(await this.Service.UnblockUserAsync(MockData.Ids[0]), Is.False);
},
verify : db => this.AssertBlockedAsync(db,
new[] { MockData.Ids[1], MockData.Ids[2] },
new[] { MockData.Ids[4], MockData.Ids[5] },
new[] { "chn 1", "chn 2" },
new[] { "usr 1", "usr 2" }
)
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => Task.CompletedTask,
alter : async db => {
this.Service.Sync();
Assert.That(await this.Service.UnblockChannelAsync(MockData.Ids[0]), Is.False);
Assert.That(await this.Service.UnblockChannelAsync(MockData.Ids[1]), Is.False);
Assert.That(await this.Service.UnblockUserAsync(MockData.Ids[4]), Is.False);
Assert.That(await this.Service.UnblockUserAsync(MockData.Ids[5]), Is.False);
Assert.That(await this.Service.UnblockChannelsAsync(new[] { MockData.Ids[0], MockData.Ids[0] }), Is.Zero);
Assert.That(await this.Service.UnblockChannelsAsync(new[] { MockData.Ids[1], MockData.Ids[2] }), Is.Zero);
Assert.That(await this.Service.UnblockUsersAsync(new[] { MockData.Ids[1], MockData.Ids[2] }), Is.Zero);
Assert.That(await this.Service.UnblockUsersAsync(new[] { MockData.Ids[4], MockData.Ids[5] }), Is.Zero);
},
verify : db => Task.CompletedTask
);
}
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 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 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 RemoveEmojiReactionTriggersTests()
{
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockReactions(db);
return(Task.CompletedTask);
},
alter : async db => {
this.UpdateEmojiReactionCount(db);
this.Service.LoadData();
IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[0]);
int removed = await this.Service.RemoveEmojiReactionTriggersAsync(
MockData.Ids[0],
ers.Where(er => er.Response == Emojis.Cloud.GetDiscordName()),
new[] { "cde" });
Assert.That(removed, Is.Zero);
},
verify : db => {
Assert.That(db.EmojiReactions, Has.Exactly(this.erCount.Sum(kvp => kvp.Value)).Items);
EmojiReaction dber = db.EmojiReactions
.Where(er => er.GuildIdDb == (long)MockData.Ids[0])
.AsEnumerable()
.Single(er => er.Response == Emojis.Cloud.GetDiscordName());
Assert.That(dber.DbTriggers.Single().Trigger, Is.EqualTo("abc"));
Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[0]), Has.Exactly(5).Items);
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockReactions(db);
return(Task.CompletedTask);
},
alter : async db => {
this.UpdateEmojiReactionCount(db);
this.Service.LoadData();
IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[0]);
int removed = await this.Service.RemoveEmojiReactionTriggersAsync(
MockData.Ids[0],
ers.Where(er => er.Response == Emojis.Joystick.GetDiscordName()),
new[] { "not" });
Assert.That(removed, 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(4).Items);
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockReactions(db);
return(Task.CompletedTask);
},
alter : async db => {
this.UpdateEmojiReactionCount(db);
this.Service.LoadData();
IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[0]);
int removed = await this.Service.RemoveEmojiReactionTriggersAsync(
MockData.Ids[0],
ers.Where(er => er.Response == Emojis.Joystick.GetDiscordName()),
new[] { "NO MATCHES" });
Assert.That(removed, Is.Zero);
},
verify : db => {
Assert.That(db.EmojiReactions, Has.Exactly(this.erCount.Sum(kvp => kvp.Value)).Items);
Assert.That(this.Service.GetGuildEmojiReactions(MockData.Ids[0]), Has.Exactly(this.erCount[0]).Items);
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockReactions(db);
return(Task.CompletedTask);
},
alter : async db => {
this.UpdateEmojiReactionCount(db);
this.Service.LoadData();
IReadOnlyCollection <EmojiReaction> ers = this.Service.GetGuildEmojiReactions(MockData.Ids[1]);
int removed = await this.Service.RemoveEmojiReactionTriggersAsync(
MockData.Ids[1],
ers,
new[] { "abc" });
Assert.That(removed, Is.EqualTo(3));
},
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]), Has.Exactly(this.erCount[1] - 3).Items);
return(Task.CompletedTask);
}
);
}
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 RemoveAsyncTests()
{
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async _ => Assert.That(await this.Service.RemoveAsync(MockData.Ids.Take(2)), Is.EqualTo(2)),
verify : db => {
Assert.That(this.Service.GetIds(), Is.Empty);
Assert.That(db.PrivilegedUsers, Is.Empty);
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async _ => Assert.That(await this.Service.RemoveAsync(MockData.Ids[1]), Is.EqualTo(1)),
verify : db => {
Assert.That(this.Service.GetIds().Single(), Is.EqualTo(MockData.Ids[0]));
Assert.That(db.PrivilegedUsers.Single().UserId, Is.EqualTo(MockData.Ids[0]));
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async _ => Assert.That(await this.Service.RemoveAsync(MockData.Ids[1], MockData.Ids[1], MockData.Ids[1]), Is.EqualTo(1)),
verify : db => {
Assert.That(this.Service.GetIds().Single(), Is.EqualTo(MockData.Ids[0]));
Assert.That(db.PrivilegedUsers.Single().UserId, Is.EqualTo(MockData.Ids[0]));
return(Task.CompletedTask);
}
);
await TestDbProvider.SetupAlterAndVerifyAsync(
setup : db => {
this.AddMockData(db);
return(Task.CompletedTask);
},
alter : async _ => Assert.That(await this.Service.RemoveAsync(MockData.Ids[3], MockData.Ids[4]), Is.Zero),
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.RemoveAsync(Array.Empty <ulong>()), Is.Zero);
Assert.That(await this.Service.RemoveAsync(Enumerable.Empty <ulong>()), Is.Zero);
},
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);
}
);
}
