async def test_initialization(self):
# Test AntiSpamHandler type assertion
with self.assertRaises(TypeError):
# noinspection PyTypeChecker
AntiSpamTracker(1, 2)
AntiSpamTracker(AntiSpamHandler(get_mocked_bot()), 3)
with self.assertRaises(TypeError):
# noinspection PyArgumentList
AntiSpamTracker()
ash = AntiSpamHandler(get_mocked_bot())
message_interval = ash.options.get("message_interval")
ast = AntiSpamTracker(ash, 3)
self.assertEqual(message_interval, ast.valid_global_interval)
ast = AntiSpamTracker(ash, 3, 15000)
self.assertNotEqual(message_interval, ast.valid_global_interval)
self.assertEqual(15000, ast.valid_global_interval)
self.assertEqual(False, bool(ast.user_tracking))
self.assertEqual(ast.punish_min_amount, 3)
with self.assertRaises(TypeError):
# noinspection PyTypeChecker
AntiSpamTracker(ash, 3, dict())
async def asyncSetUp(self):
"""
Simply setup our Ash obj before usage
"""
self.ash = AntiSpamHandler(get_mocked_bot(name="bot", id=98987))
self.ash.guilds = Guild(None, 12, Static.DEFAULTS)
self.ash.guilds = Guild(None, 15, Static.DEFAULTS)
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_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_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_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_resetKickCounter(self):
# GIVEN / SETUP
user = User(get_mocked_bot(), 123454321, 12, Static.DEFAULTS)
self.ash.guilds[0].users = user
self.assertEqual(1, len(self.ash.guilds[0].users))
self.assertEqual(0, self.ash.guilds[0].users[0].kick_count)
self.ash.guilds[0].users[0].kick_count += 1
self.assertEqual(1, self.ash.guilds[0].users[0].kick_count)
# WHEN / TESTING
self.ash.reset_user_count(123454321, 12, Static.KICKCOUNTER)
# THEN / ASSERTIONS
self.assertEqual(0, self.ash.guilds[0].users[0].kick_count)
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())
async def test_resetCountersRaises(self):
# SETUP
user = User(get_mocked_bot(), 123454321, 12, Static.DEFAULTS)
self.ash.guilds[0].users = user
# ASSERTIONS / TESTING
with self.assertRaises(LogicError):
self.ash.reset_user_count(123454321, 12, "Who knows")
# Invalid guild, should work silently
self.ash.reset_user_count(123454321, 15, "Who knows")
# Invalid user, should work silently
self.ash.reset_user_count(1234, 12, "Who knows")
# Invalid both, should work silently
self.ash.reset_user_count(1234, 15, "Who knows")
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)
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_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_warnOnly(self):
ash = AntiSpamHandler(get_mocked_bot(), warn_only=True)
self.assertEqual(ash.options["warn_only"], True)
self.assertEqual(self.ash.options["warn_only"], False)
ash = AntiSpamHandler(get_mocked_bot(), warn_only=None)
self.assertEqual(ash.options["warn_only"], False)
with self.assertRaises(ValueError):
AntiSpamHandler(get_mocked_bot(), warn_only=1)
with self.assertRaises(ValueError):
AntiSpamHandler(get_mocked_bot(), warn_only="1")
with self.assertRaises(ValueError):
AntiSpamHandler(get_mocked_bot(), warn_only=dict())
with self.assertRaises(ValueError):
AntiSpamHandler(get_mocked_bot(), warn_only=[])
async def test_ASHRandomVar(self):
with self.assertRaises(TypeError):
AntiSpamHandler(get_mocked_bot(), logging.NOTSET, lol=1)
with self.assertRaises(TypeError):
self.ash.add_custom_guild_options(1234, testing=1)