async def test_propagateGuildCreation(self):
self.assertEqual(len(self.ash.guilds), 2)
await self.ash.propagate(get_mocked_message(guild_kwargs={"id": 15}))
self.assertEqual(len(self.ash.guilds), 2)
await self.ash.propagate(get_mocked_message())
self.assertEqual(len(self.ash.guilds), 3)
async def test_updateCache(self):
ast = AntiSpamTracker(AntiSpamHandler(get_mocked_bot()), 3)
self.assertEqual(False, bool(ast.user_tracking))
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
self.assertEqual(True, bool(ast.user_tracking))
ast.user_tracking = {} # overwrite so we can test more
self.assertEqual(False, bool(ast.user_tracking))
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": False})
self.assertEqual(False, bool(ast.user_tracking))
with self.assertRaises(TypeError):
# noinspection PyTypeChecker
ast.update_cache(1, dict())
with self.assertRaises(TypeError):
# noinspection PyTypeChecker
ast.update_cache(get_mocked_message(), 1)
ast.user_tracking = {}
self.assertEqual(0, len(ast.user_tracking))
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
self.assertEqual(1, len(ast.user_tracking))
self.assertEqual(1, len(ast.user_tracking[123456789]))
self.assertEqual(2, len(ast.user_tracking[123456789][12345]))
async def test_propagateUserIgnore(self):
self.ash.add_ignored_item(12345, "member")
result = await self.ash.propagate(get_mocked_message())
self.assertEqual(result["status"], "Ignoring this user: 12345")
result_two = await self.ash.propagate(
get_mocked_message(member_kwargs={"id": 5433221}))
self.assertNotEqual(result_two["status"], "Ignoring this user: 12345")
async def test_propagateBotIgnore(self):
result = await self.ash.propagate(
get_mocked_message(member_kwargs={"bot": True, "id": 98987})
)
self.assertEqual(result["status"], "Ignoring messages from myself (the bot)")
result_two = await self.ash.propagate(
get_mocked_message(member_kwargs={"bot": True, "id": 98798})
)
self.assertEqual(result_two["status"], "Ignoring messages from bots")
async def test_propagate(self):
m = get_mocked_message(
message_id=0, member_kwargs={"id": 0}, guild_kwargs={"id": 3}
)
# TODO Use AsyncMock or Monkeypatch __await__
for i in range(5):
await self.user.propagate(
get_mocked_message(
message_id=i, member_kwargs={"id": 0}, guild_kwargs={"id": 3}
)
)
async def test_removeOutdatedTimestamps(self):
ast = AntiSpamTracker(AntiSpamHandler(get_mocked_bot()), 3, 50)
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
self.assertEqual(ast.get_user_count(get_mocked_message()), 1)
ast.remove_outdated_timestamps(123456789, 12345)
self.assertEqual(ast.get_user_count(get_mocked_message()), 1)
await asyncio.sleep(0.06)
ast.remove_outdated_timestamps(123456789, 12345)
self.assertEqual(ast.get_user_count(get_mocked_message()), 0)
async def test_removePunishment(self):
ast = AntiSpamTracker(AntiSpamHandler(get_mocked_bot()), 5)
ast.remove_punishments(get_mocked_message())
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
self.assertEqual(1, ast.get_user_count(get_mocked_message()))
ast.remove_punishments(get_mocked_message())
with self.assertRaises(UserNotFound):
ast.get_user_count(get_mocked_message())
async def test_propagateIgnoreGuild(self):
self.ash.add_ignored_item(123456789, "guild")
self.assertEqual(self.ash.options["ignore_guilds"], [123456789])
result = await self.ash.propagate(get_mocked_message())
self.assertEqual(result["status"], "Ignoring this guild: 123456789")
self.ash.remove_ignored_item(123456789, "guild")
self.assertEqual(self.ash.options["ignore_guilds"], [])
async def test_propagateIgnoredChannel(self):
self.ash.add_ignored_item(98987, "channel")
self.assertEqual(self.ash.options["ignore_channels"], [98987])
result = await self.ash.propagate(get_mocked_message())
self.assertEqual(result["status"], "Ignoring this channel: 98987")
self.ash.remove_ignored_item(98987, "channel")
self.assertEqual(self.ash.options["ignore_channels"], [])
async def test_propagateRoleIgnoring(self):
"""
Tests if the propagate method ignores the correct roles
"""
ash = AntiSpamHandler(get_mocked_member(name="bot", id="87678"),
ignore_roles=[151515])
result = await ash.propagate(get_mocked_message())
self.assertEqual(result["status"], "Ignoring this role: 151515")
async def test_getGuildValidInterval(self):
ast = AntiSpamTracker(AntiSpamHandler(get_mocked_bot()), 3)
self.assertEqual(ast._get_guild_valid_interval(123456789), 30000)
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
self.assertEqual(ast._get_guild_valid_interval(123456789), 30000)
ast.user_tracking[123456789]["valid_interval"] = 15000
self.assertEqual(ast._get_guild_valid_interval(123456789), 15000)
async def test_cleanCache(self):
ast = AntiSpamTracker(AntiSpamHandler(get_mocked_bot()), 3, 50)
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
self.assertEqual(1, len(ast.user_tracking[123456789][12345]))
ast.clean_cache()
self.assertEqual(len(ast.user_tracking), 1)
self.assertEqual(1, len(ast.user_tracking[123456789][12345]))
await asyncio.sleep(0.06)
# This should now fully clean the cache
ast.clean_cache()
self.assertEqual(ast.user_tracking, dict())
def test_transformMessage(self):
warn_embed_dict = {
"title":
"**Dear $USERNAME**",
"description":
"You are being warned for spam, please stop!",
"color":
0xFF0000,
"footer": {
"text": "$BOTNAME"
},
"author": {
"name": "$GUILDNAME"
},
"fields": [
{
"name": "Current warns:",
"value": "$WARNCOUNT"
},
{
"name": "Current kicks:",
"value": "$KICKCOUNT",
"inline": False
},
],
}
mock_message = get_mocked_message()
warn_dict = {"warn_count": 1, "kick_count": 2}
test_embed = transform_message(warn_embed_dict, mock_message,
warn_dict)
embed = discord.Embed(
title="**Dear Skelmis**",
description="You are being warned for spam, please stop!",
color=0xFF0000,
)
embed.set_footer(text="Bot")
embed.set_author(name="Guild")
embed.add_field(name="Current warns:", value="1")
embed.add_field(name="Current kicks:", value="2", inline=False)
self.assertEqual(embed.to_dict(), test_embed.to_dict())
message = transform_message("Hello $MENTIONUSER", mock_message,
warn_dict)
self.assertEqual("Hello <@12345>", message)
async def test_isSpamming(self):
ast = AntiSpamTracker(AntiSpamHandler(get_mocked_bot()), 5)
self.assertEqual(ast.is_spamming(get_mocked_message()), False)
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
self.assertEqual(ast.is_spamming(get_mocked_message()), False)
for i in range(3):
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
# Cap is 5, should have 4 messages rn
self.assertEqual(ast.is_spamming(get_mocked_message()), False)
self.assertEqual(4, len(ast.user_tracking[123456789][12345]))
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
self.assertEqual(ast.is_spamming(get_mocked_message()), True)
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
self.assertEqual(ast.is_spamming(get_mocked_message()), True)
async def test_propagateGuildPerms(self):
ash = AntiSpamHandler(get_mocked_bot())
message = get_mocked_message()
message.guild.me.guild_permissions.kick_members = False
message.guild.me.guild_permissions.ban_members = True
with self.assertRaises(MissingGuildPermissions,
msg="Invalid kick_members perms"):
await ash.propagate(message)
message.guild.me.guild_permissions.kick_members = True
message.guild.me.guild_permissions.ban_members = False
with self.assertRaises(MissingGuildPermissions,
msg="Invalid ban_members perms"):
await ash.propagate(message)
message.guild.me.guild_permissions.ban_members = True
await ash.propagate(message)
def test_dictToEmbed(self):
warn_embed_dict = {
"title":
"**Dear Dave**",
"description":
"You are being warned for spam, please stop!",
"color":
0xFF0000,
"footer": {
"text": "BOT"
},
"author": {
"name": "Guild"
},
"fields": [
{
"name": "Current warns:",
"value": "1"
},
{
"name": "Current kicks:",
"value": "2",
"inline": False
},
],
}
mock_message = get_mocked_message()
test_embed = dict_to_embed(warn_embed_dict, mock_message, {
"warn_count": 1,
"kick_count": 2
})
embed = discord.Embed(
title="**Dear Dave**",
description="You are being warned for spam, please stop!",
color=0xFF0000,
)
embed.set_footer(text="BOT")
embed.set_author(name="Guild")
embed.add_field(name="Current warns:", value="1")
embed.add_field(name="Current kicks:", value="2", inline=False)
self.assertEqual(embed.to_dict(), test_embed.to_dict())
async def test_noPunishMode(self):
# SETUP
ash = AntiSpamHandler(get_mocked_bot(), no_punish=True)
# WHEN / TESTING
data = []
for num in range(6):
return_value = await ash.propagate(
get_mocked_message(message_id=num))
data.append(return_value)
# THEN / ASSERTIONS
self.assertEqual(len(data), 6)
# TODO Fix this while fixing #39
self.assertEqual(data[0]["should_be_punished_this_message"], False)
self.assertEqual(data[2]["should_be_punished_this_message"], False)
self.assertEqual(data[3]["should_be_punished_this_message"], True)
self.assertEqual(data[5]["should_be_punished_this_message"], True)
async def test_getUserCount(self):
ast = AntiSpamTracker(AntiSpamHandler(get_mocked_bot()), 3)
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
user_count = ast.get_user_count(get_mocked_message())
self.assertEqual(user_count, 1)
for i in range(3):
ast.update_cache(get_mocked_message(),
{"should_be_punished_this_message": True})
user_count = ast.get_user_count(get_mocked_message())
self.assertEqual(user_count, 4)
with self.assertRaises(UserNotFound):
message = get_mocked_message(guild_kwargs={"id": 15})
ast.get_user_count(message)
with self.assertRaises(UserNotFound):
message = get_mocked_message(member_kwargs={"id": 25})
ast.get_user_count(message)
async def test_propagateDmIgnore(self):
result = await self.ash.propagate(get_mocked_message(is_in_guild=False)
)
self.assertEqual(result["status"], "Ignoring messages from dm's")
