async def test_kick_called(self, ctx, sync, kick):
"""Tests if silence command calls kick on a voice channel."""
channel = MockVoiceChannel()
await self.cog.silence.callback(self.cog, ctx, channel, 10, kick=True)
kick.assert_awaited_once_with(channel)
sync.assert_not_called()
def setUp(self) -> None:
self.bot = MockBot()
self.cog = silence.Silence(self.bot)
self.text_channels = [MockTextChannel() for _ in range(2)]
self.bot.get_channel.return_value = self.text_channels[1]
self.voice_channel = MockVoiceChannel()
async def test_sync_move_to_error(self):
"""Test to ensure move_to gets called on all members during sync, even if some fail."""
await self.cog._async_init()
failing_member, members = self.create_erroneous_members()
await self.cog._force_voice_sync(MockVoiceChannel(members=members))
for member in members:
self.assertEqual(member.move_to.call_count, 1 if member == failing_member else 2)
async def test_kick_move_to_error(self):
"""Test to ensure move_to gets called on all members during kick, even if some fail."""
await self.cog._async_init()
_, members = self.create_erroneous_members()
await self.cog._kick_voice_members(MockVoiceChannel(members=members))
for member in members:
member.move_to.assert_awaited_once()
async def test_skipped_already_unsilenced(self):
"""Permissions were not set and `False` was returned for an already unsilenced channel."""
self.cog.scheduler.__contains__.return_value = False
self.cog.previous_overwrites.get.return_value = None
for channel in (MockVoiceChannel(), MockTextChannel()):
with self.subTest(channel=channel):
self.assertFalse(await self.cog._unsilence(channel))
channel.set_permissions.assert_not_called()
async def test_skipped_already_silenced(self):
"""Permissions were not set and `False` was returned for an already silenced channel."""
subtests = (
(False, MockTextChannel(), PermissionOverwrite(send_messages=False, add_reactions=False)),
(True, MockTextChannel(), PermissionOverwrite(send_messages=True, add_reactions=True)),
(True, MockTextChannel(), PermissionOverwrite(send_messages=False, add_reactions=False)),
(False, MockVoiceChannel(), PermissionOverwrite(connect=False, speak=False)),
(True, MockVoiceChannel(), PermissionOverwrite(connect=True, speak=True)),
(True, MockVoiceChannel(), PermissionOverwrite(connect=False, speak=False)),
)
for contains, channel, overwrite in subtests:
with self.subTest(contains=contains, is_text=isinstance(channel, MockTextChannel), overwrite=overwrite):
self.cog.scheduler.__contains__.return_value = contains
channel.overwrites_for.return_value = overwrite
self.assertFalse(await self.cog._set_silence_overwrites(channel))
channel.set_permissions.assert_not_called()
async def test_force_voice_sync_no_channel(self):
"""Test to ensure _force_voice_sync can create its own voice channel if one is not available."""
await self.cog._async_init()
channel = MockVoiceChannel(guild=MockGuild(afk_channel=None))
new_channel = MockVoiceChannel(delete=AsyncMock())
channel.guild.create_voice_channel.return_value = new_channel
await self.cog._force_voice_sync(channel)
# Check channel creation
overwrites = {
channel.guild.default_role: PermissionOverwrite(speak=False, connect=False, view_channel=False)
}
channel.guild.create_voice_channel.assert_awaited_once_with("mute-temp", overwrites=overwrites)
# Check bot deleted channel
new_channel.delete.assert_awaited_once()
async def test_unsilence_role(self):
"""Tests unsilence_wrapper applies permission to the correct role."""
test_cases = (
(MockTextChannel(), self.cog.bot.get_guild(Guild.id).default_role),
(MockVoiceChannel(), self.cog.bot.get_guild(Guild.id).get_role(Roles.voice_verified))
)
for channel, role in test_cases:
with self.subTest(channel=channel, role=role):
await self.cog._unsilence_wrapper(channel, MockContext())
channel.overwrites_for.assert_called_with(role)
async def test_voice_kick(self):
"""Test to ensure kick function can remove all members from a voice channel."""
await self.cog._async_init()
# Create a regular member, and one member for each of the moderation roles
moderation_members = [MockMember(roles=[MockRole(id=role)]) for role in MODERATION_ROLES]
members = [MockMember(), *moderation_members]
channel = MockVoiceChannel(members=members)
await self.cog._kick_voice_members(channel)
for member in members:
if member in moderation_members:
member.move_to.assert_not_called()
else:
self.assertEqual((None,), member.move_to.call_args_list[0].args)
def setUp(self) -> None:
self.bot = MockBot(get_channel=lambda _: MockTextChannel())
self.cog = silence.Silence(self.bot)
self.cog._init_task = asyncio.Future()
self.cog._init_task.set_result(None)
# Avoid unawaited coroutine warnings.
self.cog.scheduler.schedule_later.side_effect = lambda delay, task_id, coro: coro.close()
asyncio.run(self.cog._async_init()) # Populate instance attributes.
self.text_channel = MockTextChannel()
self.text_overwrite = PermissionOverwrite(send_messages=True, add_reactions=False)
self.text_channel.overwrites_for.return_value = self.text_overwrite
self.voice_channel = MockVoiceChannel()
self.voice_overwrite = PermissionOverwrite(connect=True, speak=True)
self.voice_channel.overwrites_for.return_value = self.voice_overwrite
async def test_sent_correct_message(self):
"""Appropriate failure/success message was sent by the command to the correct channel."""
# The following test tuples are made up of:
# duration, expected message, and the success of the _set_silence_overwrites function
test_cases = (
(
0.0001,
silence.MSG_SILENCE_SUCCESS.format(duration=0.0001),
True,
),
(
None,
silence.MSG_SILENCE_PERMANENT,
True,
),
(
5,
silence.MSG_SILENCE_FAIL,
False,
),
)
targets = (MockTextChannel(), MockVoiceChannel(), None)
for (duration, message,
was_silenced), target in itertools.product(test_cases, targets):
with mock.patch.object(self.cog,
"_set_silence_overwrites",
return_value=was_silenced):
with self.subTest(was_silenced=was_silenced,
target=target,
message=message):
with mock.patch.object(self.cog,
"send_message") as send_message:
ctx = MockContext()
await self.cog.silence.callback(
self.cog, ctx, target, duration)
send_message.assert_called_once_with(
message,
ctx.channel,
target or ctx.channel,
alert_target=was_silenced)
def setUp(self) -> None:
self.bot = MockBot(get_channel=lambda _: MockTextChannel())
self.cog = silence.Silence(self.bot)
self.cog._init_task = asyncio.Future()
self.cog._init_task.set_result(None)
overwrites_cache = mock.create_autospec(self.cog.previous_overwrites, spec_set=True)
self.cog.previous_overwrites = overwrites_cache
asyncio.run(self.cog._async_init()) # Populate instance attributes.
self.cog.scheduler.__contains__.return_value = True
overwrites_cache.get.return_value = '{"send_messages": true, "add_reactions": false}'
self.text_channel = MockTextChannel()
self.text_overwrite = PermissionOverwrite(send_messages=False, add_reactions=False)
self.text_channel.overwrites_for.return_value = self.text_overwrite
self.voice_channel = MockVoiceChannel()
self.voice_overwrite = PermissionOverwrite(connect=True, speak=True)
self.voice_channel.overwrites_for.return_value = self.voice_overwrite
async def test_force_voice_sync(self):
"""Tests the _force_voice_sync helper function."""
await self.cog._async_init()
# Create a regular member, and one member for each of the moderation roles
moderation_members = [MockMember(roles=[MockRole(id=role)]) for role in MODERATION_ROLES]
members = [MockMember(), *moderation_members]
channel = MockVoiceChannel(members=members)
await self.cog._force_voice_sync(channel)
for member in members:
if member in moderation_members:
member.move_to.assert_not_called()
else:
self.assertEqual(member.move_to.call_count, 2)
calls = member.move_to.call_args_list
# Tests that the member was moved to the afk channel, and back.
self.assertEqual((channel.guild.afk_channel,), calls[0].args)
self.assertEqual((channel,), calls[1].args)
async def test_cache_miss_sent_mod_alert_voice(self):
"""A message was sent to the mod alerts channel upon muting a voice channel."""
self.cog.previous_overwrites.get.return_value = None
await self.cog._unsilence(MockVoiceChannel())
self.cog._mod_alerts_channel.send.assert_awaited_once()