def test_compare_crew_and_power(self):
author = mocks.MockMember(display_name='Bob')
target = mocks.MockMember(display_name='Joe')
bot = mocks.MockSSB(cache=mocks.cache())
with self.subTest('Different crews'):
author.roles = [mocks.hk_role]
target.roles = [mocks.fsg_role]
with self.assertRaises(ValueError) as ve:
compare_crew_and_power(author, target, bot)
self.assertEqual(
str(ve.exception),
f'{author.display_name} on {mocks.hk_role.name} '
f'cannot unflair {target.display_name} on {mocks.fsg_role.name}'
)
with self.subTest('Admin'):
author.roles = [mocks.admin]
target.roles = [mocks.fsg_role]
self.assertIsNone(compare_crew_and_power(author, target, bot))
with self.subTest('Leader:Leader'):
author.roles = [mocks.hk_role, mocks.leader]
target.roles = [mocks.hk_role, mocks.leader]
with self.assertRaises(ValueError) as ve:
compare_crew_and_power(author, target, bot)
self.assertEqual(
str(ve.exception),
f'A majority of leaders must approve unflairing leader{target.mention}.'
f' Tag the Doc Keeper role in {bot.cache.channels.flairing_questions} for assistance.'
)
with self.subTest('Advisor:Advisor'):
author.roles = [mocks.hk_role, mocks.advisor]
target.roles = [mocks.hk_role, mocks.advisor]
with self.assertRaises(ValueError) as ve:
compare_crew_and_power(author, target, bot)
self.assertEqual(
str(ve.exception),
f' cannot unflair {target.mention} as you are not powerful enough.'
)
with self.subTest('No power.'):
author.roles = [mocks.hk_role]
target.roles = [mocks.hk_role]
with self.assertRaises(ValueError) as ve:
compare_crew_and_power(author, target, bot)
self.assertEqual(
str(ve.exception),
'You must be an advisor, leader or staff to unflair others.')
with self.subTest('Leader:Advisor'):
author.roles = [mocks.hk_role, mocks.leader]
target.roles = [mocks.hk_role, mocks.advisor]
self.assertIsNone(compare_crew_and_power(author, target, bot))
with self.subTest('Leader:Nothing'):
author.roles = [mocks.hk_role, mocks.leader]
target.roles = [mocks.hk_role]
self.assertIsNone(compare_crew_and_power(author, target, bot))
with self.subTest('Advisor:Nothing'):
author.roles = [mocks.hk_role, mocks.advisor]
target.roles = [mocks.hk_role]
self.assertIsNone(compare_crew_and_power(author, target, bot))
def test_mock_guild_alternative_arguments(self):
"""Test if MockGuild initializes with the arguments provided."""
core_developer = mocks.MockRole(name="Core Developer", position=2)
guild = mocks.MockGuild(
roles=[core_developer],
members=[mocks.MockMember(id=54321)],
)
self.assertListEqual(guild.roles, [
mocks.MockRole(name="@everyone", position=1, id=0), core_developer
])
self.assertListEqual(guild.members, [mocks.MockMember(id=54321)])
async def test_track_cycle(self):
member = mocks.MockMember()
scs = mocks.MockGuild(roles=mocks.tracks)
with self.subTest('No track'):
res = await track_cycle(member, scs)
self.assertEqual(0, res)
self.assertIn(mocks.track1, member.roles)
with self.subTest('Track 1->2'):
member.roles = [mocks.track1]
res = await track_cycle(member, scs)
self.assertEqual(1, res)
self.assertIn(mocks.track2, member.roles)
self.assertNotIn(mocks.track1, member.roles)
with self.subTest('Track 2->3'):
member.roles = [mocks.track2]
res = await track_cycle(member, scs)
self.assertEqual(2, res)
self.assertIn(mocks.track3, member.roles)
self.assertNotIn(mocks.track2, member.roles)
with self.subTest('Track 3'):
member.roles = [mocks.track3]
res = await track_cycle(member, scs)
self.assertEqual(3, res)
with self.subTest('full'):
member.roles = [mocks.true_locked]
res = await track_cycle(member, scs)
self.assertEqual(3, res)
async def test_flair(self):
bot = mocks.MockSSB(cache=mocks.cache())
bob = mocks.MockMember(name='bob', id=1)
with self.subTest('True Locked'):
bob.roles = [mocks.MockRole(name=TRUE_LOCKED)]
with self.assertRaises(ValueError) as ve:
await flair(bob, mocks.HK, bot)
self.assertEqual(
str(ve.exception),
f'{bob.display_name} cannot be flaired because they are {TRUE_LOCKED}.'
)
with self.subTest('Join CD'):
bob.roles = [mocks.MockRole(name=JOIN_CD)]
with self.assertRaises(ValueError) as ve:
await flair(bob, mocks.HK, bot)
self.assertEqual(
str(ve.exception),
f'{bob.display_name} cannot be flaired because they have {JOIN_CD}.'
)
with self.subTest('Free Agent non overflow.'):
bob.roles = [bot.cache.roles.free_agent]
await flair(bob, mocks.HK, bot)
after = set(bob.roles)
expected = {mocks.hk_role, bot.cache.roles.join_cd}
self.assertEqual(expected, after)
with self.subTest('Track 2 non overflow.'):
bob.roles = [bot.cache.roles.track3]
await flair(bob, mocks.HK, bot)
after = set(bob.roles)
expected = {
mocks.hk_role, bot.cache.roles.join_cd,
bot.cache.roles.true_locked
}
self.assertEqual(expected, after)
with self.subTest('Overflow.'):
overflow_bob = mocks.MockMember(name='bob', id=1)
bob.roles = [bot.cache.roles.overflow]
bot.cache.overflow_server.members = [overflow_bob]
await flair(bob, mocks.Ballers, bot)
after_main = set(bob.roles)
expected_main = {bot.cache.roles.join_cd, bot.cache.roles.overflow}
self.assertEqual(expected_main, after_main)
after_overflow = set(overflow_bob.roles)
self.assertIn(mocks.ballers_role, after_overflow)
def test_mock_member_accepts_dynamic_arguments(self):
"""Test if MockMember accepts and sets abitrary keyword arguments."""
member = mocks.MockMember(
nick="Dino Man",
colour=discord.Colour.default(),
)
self.assertEqual(member.nick, "Dino Man")
self.assertEqual(member.colour, discord.Colour.default())
def test_crew(self):
member = mocks.MockMember(name='Steve', id=int('4' * 17))
hk = mocks.HK
role = mocks.MockRole(name=hk.name)
bot = mocks.MockSSB(cache=mocks.cache())
with self.subTest('Not on a crew.'):
member.roles = []
with self.assertRaises(Exception):
crew(member, bot)
with self.subTest('On a crew.'):
member.roles = [role]
self.assertEqual(hk.name, crew(member, bot))
with self.subTest('On overflow crew.'):
member.roles = [bot.cache.roles.overflow]
of_member = mocks.MockMember(name='Steve',
id=int('4' * 17),
roles=[mocks.ballers_role])
bot.cache.overflow_server.members.append(of_member)
self.assertEqual(mocks.Ballers.name, crew(member, bot))
def test_mock_member_default_initialization(self):
"""Test if the default initialization of Mockmember results in the correct object."""
member = mocks.MockMember()
# The `spec` argument makes sure `isistance` checks with `discord.Member` pass
self.assertIsInstance(member, discord.Member)
self.assertEqual(member.name, "member")
self.assertListEqual(
member.roles, [mocks.MockRole(name="@everyone", position=1, id=0)])
self.assertEqual(member.mention, f"<@!{member.id}>")
def test_mock_member_alternative_arguments(self):
"""Test if MockMember initializes with the arguments provided."""
core_developer = mocks.MockRole(name="Core Developer", position=2)
member = mocks.MockMember(name="Mark",
id=12345,
roles=[core_developer])
self.assertEqual(member.name, "Mark")
self.assertEqual(member.id, 12345)
self.assertListEqual(member.roles, [
mocks.MockRole(name="@everyone", position=1, id=0), core_developer
])
self.assertEqual(member.mention, "<@!12345>")
def test_power_level(self):
member = mocks.MockMember()
with self.subTest('No power'):
self.assertEqual(0, power_level(member))
with self.subTest('Advisor'):
member.roles = [mocks.advisor]
self.assertEqual(1, power_level(member))
with self.subTest('Leader'):
member.roles = [mocks.advisor, mocks.leader]
self.assertEqual(2, power_level(member))
with self.subTest('Admin'):
member.roles = [mocks.advisor, mocks.leader, mocks.admin]
self.assertEqual(3, power_level(member))
def test_mocks_rejects_access_to_attributes_not_part_of_spec(self):
"""Accessing attributes that are invalid for the objects they mock should fail."""
mock_tuple = (
mocks.MockGuild(),
mocks.MockRole(),
mocks.MockMember(),
mocks.MockBot(),
mocks.MockContext(),
mocks.MockTextChannel(),
mocks.MockMessage(),
)
for mock in mock_tuple:
with self.subTest(mock=mock):
with self.assertRaises(AttributeError):
mock.the_cake_is_a_lie
def test_check_roles(self):
member = mocks.MockMember()
with self.subTest('None equal'):
member.roles = [mocks.role_instance]
self.assertFalse(check_roles(member, [mocks.leader_instance.name]))
with self.subTest('One equal'):
member.roles = [
mocks.leader_instance, mocks.overflow_role_instance
]
self.assertTrue(check_roles(member, [mocks.leader_instance.name]))
with self.subTest('Both equal'):
member.roles = [
mocks.overflow_role_instance, mocks.leader_instance
]
self.assertTrue(
check_roles(
member,
[mocks.leader_instance.name, mocks.role_instance.name]))
def test_mocks_allows_access_to_attributes_part_of_spec(self):
"""Accessing attributes that are valid for the objects they mock should succeed."""
mock_tuple = (
(mocks.MockGuild(), 'name'),
(mocks.MockRole(), 'hoist'),
(mocks.MockMember(), 'display_name'),
(mocks.MockBot(), 'user'),
(mocks.MockContext(), 'invoked_with'),
(mocks.MockTextChannel(), 'last_message'),
(mocks.MockMessage(), 'mention_everyone'),
)
for mock, valid_attribute in mock_tuple:
with self.subTest(mock=mock):
try:
getattr(mock, valid_attribute)
except AttributeError:
msg = f"accessing valid attribute `{valid_attribute}` raised an AttributeError"
self.fail(msg)
