def test_delete_action(self):
"""Unit tests for gestion_actions.delete_action function."""
# def delete_action(action)
delete_action = gestion_actions.delete_action
mock_bdd.add_campsroles()
j1 = bdd.Joueur(discord_id=1, chan_id_=11, nom="Joueur1")
j1.add()
# no taches
ba1 = bdd.BaseAction(slug="ba1")
ba1.add()
act1 = bdd.Action(base=ba1, joueur=j1)
act1.add()
delete_action(act1)
self.assertEqual(bdd.Action.query.all(), [])
self.assertEqual(bdd.Tache.query.all(), [])
# some taches
act1 = bdd.Action(base=ba1, joueur=j1)
act1.add()
bdd.Tache(timestamp=datetime.datetime.now(), commande="t1",
action=act1).add()
bdd.Tache(timestamp=datetime.datetime(2021, 3, 15, 15, 2, 0),
commande="t2", action=act1).add()
delete_action(act1)
self.assertEqual(bdd.Action.query.all(), [])
self.assertEqual(bdd.Tache.query.all(), [])
async def test_get_actions(self, da_patch):
"""Unit tests for gestion_actions.get_actions function."""
# def get_actions(quoi, trigger, heure=None)
get_actions = gestion_actions.get_actions
mock_bdd.add_campsroles()
j1 = bdd.Joueur(discord_id=1, chan_id_=11, nom="Joueur1")
j1.add()
perma, temporel = bdd.ActionTrigger.perma, bdd.ActionTrigger.temporel
bap = bdd.BaseAction(slug="bap", trigger_debut=perma,
trigger_fin=perma)
bat = bdd.BaseAction(slug="bat", trigger_debut=temporel,
heure_debut=datetime.time(15, 4),
trigger_fin=temporel,
heure_fin=datetime.time(22, 15))
bdd.BaseAction.add(bap, bat)
act_pn = bdd.Action(id=1, base=bap, joueur=j1, decision_=None)
act_pr = bdd.Action(id=2, base=bap, joueur=j1, decision_="rien")
act_pq = bdd.Action(id=3, base=bap, joueur=j1, decision_="qqch")
act_tn = bdd.Action(id=4, base=bat, joueur=j1, decision_=None)
act_tr = bdd.Action(id=5, base=bat, joueur=j1, decision_="rien")
act_tq = bdd.Action(id=6, base=bat, joueur=j1, decision_="qqch")
bdd.Action.add(act_pn, act_pr, act_pq, act_tn, act_tr, act_tq)
samples = {
("open", bdd.ActionTrigger.mort, None): set(),
("close", bdd.ActionTrigger.mort, None): set(),
("remind", bdd.ActionTrigger.mort, None): set(),
("open", perma, None): {act_pn},
("close", perma, None): {act_pr, act_pq},
("remind", perma, None): {act_pr},
("open", temporel, None): discord.ext.commands.UserInputError,
("close", temporel, None): discord.ext.commands.UserInputError,
("remind", temporel, None): discord.ext.commands.UserInputError,
("open", temporel, datetime.time(15, 4)): {act_tn},
("close", temporel, datetime.time(15, 4)): set(),
("remind", temporel, datetime.time(15, 4)): set(),
("open", temporel, datetime.time(22, 15)): set(),
("close", temporel, datetime.time(22, 15)): {act_tr, act_tq},
("remind", temporel, datetime.time(22, 15)): {act_tr},
("open", temporel, datetime.time(3, 25)): set(),
("close", temporel, datetime.time(3, 25)): set(),
("remind", temporel, datetime.time(3, 25)): set(),
("bzz", perma, None): discord.ext.commands.UserInputError,
}
for ((quoi, trigger, heure), result) in samples.items():
if isinstance(result, type) and issubclass(result, Exception):
with self.assertRaises(result):
if heure:
get_actions(quoi, trigger, heure)
else:
get_actions(quoi, trigger, heure)
else:
if heure:
actions = get_actions(quoi, trigger, heure)
else:
actions = get_actions(quoi, trigger, heure)
self.assertEqual(set(actions), result)
def test_add_action(self):
"""Unit tests for gestion_actions.add_action function."""
# def add_action(action)
add_action = gestion_actions.add_action
mock_bdd.add_campsroles()
j1 = bdd.Joueur(discord_id=1, chan_id_=11, nom="Joueur1")
j1.add()
# basic
ba1 = bdd.BaseAction(slug="ba1", trigger_debut=bdd.ActionTrigger.mort)
ba1.add()
act1 = bdd.Action(base=ba1, joueur=j1)
add_action(act1)
self.assertEqual(bdd.Action.query.all(), [act1])
self.assertEqual(bdd.Tache.query.all(), [])
act1.delete()
# temporel
ba2 = bdd.BaseAction(slug="ba2",
trigger_debut=bdd.ActionTrigger.temporel,
heure_debut=datetime.time(15, 2))
ba2.add()
act2 = bdd.Action(id=25, base=ba2, joueur=j1)
add_action(act2)
self.assertEqual(bdd.Action.query.all(), [act2])
self.assertEqual(len(bdd.Tache.query.all()), 1)
tache = bdd.Tache.query.one()
self.assertEqual(tache.timestamp.time(), datetime.time(15, 2))
self.assertEqual(tache.commande, "!open 25")
self.assertEqual(tache.action, act2)
act2.delete()
tache.delete()
# perma
ba3 = bdd.BaseAction(slug="ba3", trigger_debut=bdd.ActionTrigger.perma)
ba3.add()
act3 = bdd.Action(id=23, base=ba3, joueur=j1)
add_action(act3)
self.assertEqual(bdd.Action.query.all(), [act3])
self.assertEqual(len(bdd.Tache.query.all()), 1)
tache = bdd.Tache.query.one()
self.assertAlmostEqual(tache.timestamp, datetime.datetime.now(),
delta=datetime.timedelta(seconds=1))
self.assertEqual(tache.commande, "!open 23")
self.assertEqual(tache.action, act3)
async def test_roles(self):
"""Unit tests for !roles command."""
# async def roles(self, ctx, *, filtre=None)
roles = self.cog.roles
# !roles with no roles
ctx = mock_discord.get_ctx(roles)
await ctx.invoke()
ctx.assert_sent("Rôles trouvés :")
mock_bdd.add_campsroles(300, 300) # several panes
# !roles with a lot of roles
emoji1 = mock.Mock(name="<:emoji1:>")
emoji1.configure_mock(name="emoji1")
ctx = mock_discord.get_ctx(roles)
with mock.patch("lgrez.config.guild.emojis", [emoji1]):
await ctx.invoke()
sent = "\n".join(call.args[0] for call in ctx.send.call_args_list)
self.assertIn("Role1", sent)
self.assertIn("emoji1", sent)
self.assertNotIn("emoji2", sent)
bdd.Role(slug="chz",
nom="ChienZ",
description_courte="zoo",
description_longue="zpp" * 12,
camp=bdd.Camp.query.get("camp42")).add()
# !roles <camp>
ctx = mock_discord.get_ctx(roles, filtre="camp42")
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("Role42", ctx.send.call_args.args[0])
self.assertIn("ChienZ", ctx.send.call_args.args[0])
# !roles <role>
ctx = mock_discord.get_ctx(roles, filtre="chz")
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("ChienZ", ctx.send.call_args.args[0])
self.assertIn("Camp42", ctx.send.call_args.args[0])
self.assertIn("zoo", ctx.send.call_args.args[0])
self.assertIn("zppzpp", ctx.send.call_args.args[0])
async def test_infos(self):
"""Unit tests for !infos command."""
# async def infos(self, ctx)
infos = self.cog.infos
mock_bdd.add_campsroles(10, 10)
joueur = bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
_role_slug="role7")
joueur.add()
# no actions
ctx = mock_discord.get_ctx(infos, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("Role7", ctx.send.call_args.args[0])
self.assertIn("role7", ctx.send.call_args.args[0])
self.assertIn("Aucune action disponible", ctx.send.call_args.args[0])
# one action
bdd.BaseAction(slug="ouiZ",
trigger_debut=bdd.ActionTrigger.perma,
trigger_fin=bdd.ActionTrigger.perma).add()
bdd.Action(joueur=joueur, _base_slug="ouiZ").add()
ctx = mock_discord.get_ctx(infos, _caller_id=1)
await ctx.invoke()
ctx.assert_sent("ouiZ")
# test every triggers
names = []
for trigger in bdd.ActionTrigger:
name = f"test{trigger.name}"
bdd.BaseAction(slug=name,
trigger_debut=trigger,
trigger_fin=trigger).add()
bdd.Action(joueur=joueur, _base_slug=name).add()
names.append(name)
ctx = mock_discord.get_ctx(infos, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
for name in names:
self.assertIn(name, ctx.send.call_args.args[0])
async def test_quiest(self):
"""Unit tests for !quiest command."""
# async def quiest(self, ctx, *, nomrole)
quiest = self.cog.quiest
mock_bdd.add_campsroles(10, 10)
bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
_role_slug="role7").add()
bdd.Joueur(discord_id=2,
chan_id_=21,
nom="Joueur2",
_role_slug="role8").add()
bdd.Joueur(discord_id=3,
chan_id_=31,
nom="Joueur3",
_role_slug="role8").add()
bdd.Joueur(discord_id=4,
chan_id_=41,
nom="Joueur4",
_role_slug="role8",
statut=bdd.Statut.mort).add()
# !quiest with non-existing nomrole
ctx = mock_discord.get_ctx(quiest, nomrole="zzzzz")
await ctx.invoke()
ctx.assert_sent("")
# !quiest with existing nomrole
ctx = mock_discord.get_ctx(quiest, nomrole="role7")
await ctx.invoke()
ctx.assert_sent("Joueur1")
# check several players & dead
ctx = mock_discord.get_ctx(quiest, nomrole="role8")
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("Joueur2", ctx.send.call_args.args[0])
self.assertIn("Joueur3", ctx.send.call_args.args[0])
self.assertNotIn("Joueur4", ctx.send.call_args.args[0])
async def test_trigger_roles(self):
"""Unit tests for IA.trigger_roles function."""
# async def trigger_roles(message, sensi=0.8)
trigger_roles = IA.trigger_roles
mock_bdd.add_campsroles(10, 10)
# nothing
ctx = mock_discord.get_ctx(None)
message = mock_discord.message(ctx, "ooooo")
rep = await trigger_roles(message)
self.assertIs(rep, False)
ctx.assert_sent()
# one exact role found
ctx = mock_discord.get_ctx(None)
message = mock_discord.message(ctx, "Role3")
role3 = bdd.Role.query.get("role3")
role3.prefixe = "PREF@x"
role3.description_courte = "D€$k00rt"
role3.description_longue = "D€$k_longue"
role3.camp = bdd.Camp.query.get("camp3")
rep = await trigger_roles(message)
self.assertIs(rep, True)
ctx.assert_sent(
["Role3", "PREF@x", "D€$k00rt", "D€$k_longue", "Camp3"])
# high sensi
ctx = mock_discord.get_ctx(None)
message = mock_discord.message(ctx, "Rol")
rep = await trigger_roles(message)
self.assertIs(rep, False)
ctx.assert_sent()
# low sensi - more roles found
ctx = mock_discord.get_ctx(None)
message = mock_discord.message(ctx, "Rol")
rep = await trigger_roles(message, sensi=0.5)
self.assertIs(rep, True)
ctx.assert_sent("Role") # one selected
async def test_rolede(self):
"""Unit tests for !rolede command."""
# async def rolede(self, ctx, *, cible=None)
rolede = self.cog.rolede
mock_bdd.add_campsroles(10, 10)
bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
_role_slug="role7").add()
# !rolede with existing cible
ctx = mock_discord.get_ctx(rolede, cible="Joueur1")
await ctx.invoke()
ctx.assert_sent("Role7")
# !rolede with no cible
ctx = mock_discord.get_ctx(rolede)
with mock_discord.interact(
("wait_for_message_here", ctx.new_message("zzz")),
("wait_for_message_here", ctx.new_message("zzz")),
("wait_for_message_here", ctx.new_message("Joueur1"))):
await ctx.invoke()
ctx.assert_sent("", "", "", "Role7")
async def test_votemaire(self, export_patch):
"""Unit tests for !votemaire command."""
# async def votemaire(self, ctx, *, cible=None)
votemaire = self.cog.votemaire
mock_bdd.add_campsroles()
joueur = bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
votant_village=False,
vote_maire_="oh")
joueur.add()
export_patch.assert_not_called()
# votant_village False
ctx = mock_discord.get_ctx(votemaire, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("pas autorisé", ctx.send.call_args.args[0])
export_patch.assert_not_called()
# no votemaire
joueur.votant_village = True
joueur.vote_maire_ = None
joueur.update()
ctx = mock_discord.get_ctx(votemaire, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("pas de vote", ctx.send.call_args.args[0].lower())
export_patch.assert_not_called()
# not candid
joueur.vote_maire_ = "oh"
joueur.update()
bdd.Joueur(discord_id=2, chan_id_=21, nom="Joueur2").add()
ctx = mock_discord.get_ctx(votemaire, cible="Joueur2", _caller_id=1)
with mock_discord.interact(("yes_no", False)):
# abort (answer "no" at non-haroted warning)
await ctx.invoke()
calls = ctx.send.call_args_list
self.assertEqual(len(calls), 2)
self.assertIn("ne s'est pas (encore) présenté", calls[0].args[0])
self.assertIn("mission aborted", calls[1].args[0])
export_patch.assert_not_called()
# closed during haro check
def close_vote(_):
joueur.vote_maire_ = None
joueur.update()
return True
ctx = mock_discord.get_ctx(votemaire, cible="Joueur2", _caller_id=1)
with mock_discord.interact(("yes_no", close_vote)):
# close votemaire and answer "yes" at non-haroted warning
await ctx.invoke()
calls = ctx.send.call_args_list
self.assertEqual(len(calls), 2)
self.assertIn("a fermé entre temps", calls[1].args[0])
export_patch.assert_not_called()
# ok
joueur.vote_maire_ = "oh" # reopen votemaire
joueur.update()
bdd.CandidHaro(_joueur_id=2, type=bdd.CandidHaroType.candidature).add()
ctx = mock_discord.get_ctx(votemaire, cible="Joueur2", _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("Joueur2", ctx.send.call_args.args[0])
self.assertIn("bien pris en compte", ctx.send.call_args.args[0])
self.assertEqual(joueur.vote_maire_, "Joueur2")
export_patch.assert_called_once_with("maire", joueur)
export_patch.reset_mock()
# ok, cible not specified
joueur.vote_maire_ = "oh" # reset votemaire
joueur.update()
ctx = mock_discord.get_ctx(votemaire, _caller_id=1)
with mock_discord.interact(
("wait_for_message_here", ctx.new_message("zzz")),
("wait_for_message_here", ctx.new_message("zzz")),
("wait_for_message_here", ctx.new_message("Joueur2"))):
await ctx.invoke()
self.assertIn("Joueur2", ctx.send.call_args.args[0])
self.assertIn("bien pris en compte", ctx.send.call_args.args[0])
self.assertEqual(joueur.vote_maire_, "Joueur2")
export_patch.assert_called_once_with("maire", joueur)
export_patch.reset_mock()
async def test_export_vote(self, gconnect_patch):
"""Unit tests for voter_agir.export_vote function."""
# def export_vote(vote, joueur)
export_vote = voter_agir.export_vote
mock_bdd.add_campsroles(10, 10)
joueur = bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
_role_slug="role7",
_camp_slug="camp8",
vote_condamne_="oh",
vote_maire_="ah",
vote_loups_="eh")
joueur.add()
bdd.BaseAction(slug="ouiZ").add()
bdd.BaseAction(slug="nonZ").add()
bdd.BaseAction(slug="lalaZ").add()
bdd.Action(joueur=joueur, _base_slug="ouiZ", decision_="dZ1").add()
bdd.Action(joueur=joueur, _base_slug="nonZ", decision_="dZ2").add()
bdd.Action(joueur=joueur, _base_slug="lalaZ", decision_=None).add()
# no LGREZ_DATA_SHEET_ID
with mock_env.patch_env(LGREZ_DATA_SHEET_ID=None):
with self.assertRaises(RuntimeError):
export_vote("cond", joueur)
gconnect_patch.assert_not_called()
# vote = bad value
with self.assertRaises(ValueError):
export_vote("bzz", joueur)
gconnect_patch.assert_not_called()
# vote = "cond"
export_vote("cond", joueur)
gconnect_patch.assert_called_once_with("uiz")
gconnect_patch().worksheet.assert_called_with("votecond_brut")
gconnect_patch().worksheet().append_row.assert_called_once()
appened = gconnect_patch().worksheet().append_row.call_args.args[0]
self.assertEqual(["Joueur1", "oh"], appened[1:])
gconnect_patch.reset_mock(return_value=True)
# vote = "maire"
export_vote("maire", joueur)
gconnect_patch.assert_called_once_with("uiz")
gconnect_patch().worksheet.assert_called_with("votemaire_brut")
gconnect_patch().worksheet().append_row.assert_called_once()
appened = gconnect_patch().worksheet().append_row.call_args.args[0]
self.assertEqual(["Joueur1", "ah"], appened[1:])
gconnect_patch.reset_mock(return_value=True)
# vote = "loups"
export_vote("loups", joueur)
gconnect_patch.assert_called_once_with("uiz")
gconnect_patch().worksheet.assert_called_with("voteloups_brut")
gconnect_patch().worksheet().append_row.assert_called_once()
appened = gconnect_patch().worksheet().append_row.call_args.args[0]
self.assertEqual(["Joueur1", "camp8", "eh"], appened[1:])
gconnect_patch.reset_mock(return_value=True)
# vote = "action"
export_vote("action", joueur)
gconnect_patch.assert_called_once_with("uiz")
gconnect_patch().worksheet.assert_called_with("actions_brut")
gconnect_patch().worksheet().append_row.assert_called_once()
appened = gconnect_patch().worksheet().append_row.call_args.args[0]
self.assertEqual(["Joueur1", "role7", "camp8"], appened[1:4])
self.assertIn("ouiZ", appened[4])
self.assertIn("dZ1", appened[4])
self.assertIn("nonZ", appened[4])
self.assertIn("dZ2", appened[4])
self.assertNotIn("lalaZ", appened[4])
async def test_addhere(self):
"""Unit tests for !addhere command."""
# async def addhere(self, ctx, *joueurs)
addhere = self.cog.addhere
mock_bdd.add_campsroles(10, 10)
joueurs = [
bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
statut=bdd.Statut.vivant,
_role_slug="role1",
votant_village=True,
votant_loups=False,
role_actif=False),
bdd.Joueur(discord_id=2,
chan_id_=21,
nom="Joueur2",
chambre="ch2",
statut=bdd.Statut.vivant,
votant_village=True,
votant_loups=False,
role_actif=False),
bdd.Joueur(discord_id=3,
chan_id_=31,
nom="Joueur3",
statut=bdd.Statut.mort,
_role_slug="role3",
_camp_slug="camp3",
votant_village=True,
votant_loups=False,
role_actif=True),
bdd.Joueur(discord_id=4,
chan_id_=41,
nom="Joueur4",
chambre="ch 4",
statut=bdd.Statut.mort,
votant_village=False,
votant_loups=False,
role_actif=True),
bdd.Joueur(discord_id=5,
chan_id_=51,
nom="Joueur 5",
statut=bdd.Statut.MV,
_camp_slug="camp3",
votant_village=False,
votant_loups=False,
role_actif=False),
bdd.Joueur(discord_id=6,
chan_id_=61,
nom="Joueur6",
statut=bdd.Statut.immortel,
_role_slug="role3",
votant_village=False,
votant_loups=True,
role_actif=False),
]
bdd.Joueur.add(*joueurs)
# cible = bat filtre
ctx = mock_discord.get_ctx(addhere, "biz=oui")
with self.assertRaises(discord.ext.commands.UserInputError) as cm:
await ctx.invoke()
self.assertIn("critère 'biz' incorrect", cm.exception.args[0])
# cible = all filtres
crits = {
"discord_id=3": [2],
"chan_id_=21": [1],
"nom=Joueur4": [3],
"nom=Joueur 5": [4],
"chambre=ch2": [1],
"chambre=ch 4": [3],
"statut=vivant": [0, 1],
"statut=mort": [2, 3],
"statut=MV": [4],
"statut=immortel": [5],
"role=role1": [0],
"role=role3": [2, 5],
"camp=camp3": [2, 4],
"votant_village=True": [0, 1, 2],
"votant_village=1": [0, 1, 2],
"votant_village=faux": [3, 4, 5],
"votant_loups=vrai": [5],
"votant_loups=0": [0, 1, 2, 3, 4],
"role_actif=True": [2, 3],
"role_actif=False": [0, 1, 4, 5],
}
for crit, ijs in crits.items():
ctx = mock_discord.get_ctx(addhere, crit)
with mock_discord.mock_members_and_chans(*joueurs):
members = [joueur.member for joueur in joueurs]
with mock_discord.interact(("yes_no", False)):
await ctx.invoke()
ctx.assert_sent(*[joueurs[ij].nom for ij in ijs], "Fini")
self.assertEqual(ctx.channel.set_permissions.call_count, len(ijs))
ctx.channel.set_permissions.assert_has_calls([
mock.call(member, read_messages=True, send_messages=True)
for ij, member in enumerate(members) if ij in ijs
])
ctx.channel.purge.assert_not_called()
# cible = non-existing joueur, correct
ctx = mock_discord.get_ctx(addhere, "gouzigouzi")
with mock_discord.interact(
("wait_for_message_here", mock_discord.message(ctx, "krr")),
("wait_for_message_here", mock_discord.message(ctx, "Joueur2")),
("yes_no", False),
):
with mock_discord.mock_members_and_chans(*joueurs):
members = [joueur.member for joueur in joueurs]
await ctx.invoke()
ctx.assert_sent("Aucune entrée trouvée", "Aucune entrée trouvée",
"Joueur2", "Fini")
ctx.channel.set_permissions.assert_called_once_with(members[1],
read_messages=True,
send_messages=True)
ctx.channel.purge.assert_not_called()
# cible = existing joueur
ctx = mock_discord.get_ctx(addhere, "Joueur 5")
with mock_discord.mock_members_and_chans(*joueurs):
members = [joueur.member for joueur in joueurs]
with mock_discord.interact(("yes_no", False)):
await ctx.invoke()
ctx.assert_sent("Joueur 5", "Fini")
ctx.channel.set_permissions.assert_called_once_with(members[4],
read_messages=True,
send_messages=True)
ctx.channel.purge.assert_not_called()
# cible = several joueurs, correct some
ctx = mock_discord.get_ctx(addhere, "Joueur2", "kwdzz", "Joueur 5")
with mock_discord.interact(
("wait_for_message_here", mock_discord.message(ctx, "krr")),
("wait_for_message_here", mock_discord.message(ctx, "Joueur4")),
("yes_no", False),
):
with mock_discord.mock_members_and_chans(*joueurs):
members = [joueur.member for joueur in joueurs]
await ctx.invoke()
ctx.assert_sent("Aucune entrée trouvée", "Aucune entrée trouvée",
"Joueur2", "Joueur4", "Joueur 5", "Fini")
self.assertEqual(ctx.channel.set_permissions.call_count, 3)
ctx.channel.set_permissions.assert_has_calls([
mock.call(members[1], read_messages=True, send_messages=True),
mock.call(members[3], read_messages=True, send_messages=True),
mock.call(members[4], read_messages=True, send_messages=True),
])
ctx.channel.purge.assert_not_called()
# cible = existing joueur, purge
ctx = mock_discord.get_ctx(addhere, "Joueur 5")
with mock_discord.mock_members_and_chans(*joueurs):
members = [joueur.member for joueur in joueurs]
with mock_discord.interact(("yes_no", True)):
await ctx.invoke()
ctx.assert_sent("Joueur 5", "Fini")
ctx.channel.set_permissions.assert_called_once_with(members[4],
read_messages=True,
send_messages=True)
ctx.channel.purge.assert_called_once()
async def test_menu(self):
"""Unit tests for !menu command."""
# async def menu(self, ctx)
menu = self.cog.menu
mock_bdd.add_campsroles(10, 10)
joueur = bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
_role_slug="role7")
joueur.add()
# no vote nor actions
ctx = mock_discord.get_ctx(menu, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("MENU", ctx.send.call_args.args[0])
self.assertIn("Aucun vote en cours", ctx.send.call_args.args[0])
self.assertIn("Aucune action en cours", ctx.send.call_args.args[0])
# all votes, no actions
joueur.vote_condamne_ = "zoopla"
joueur.vote_maire_ = "zooplo"
joueur.vote_loups_ = "zoopli"
joueur.update()
ctx = mock_discord.get_ctx(menu, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
sent = ctx.send.call_args.args[0]
self.assertIn("Vote pour le bûcher en cours", sent)
self.assertIn("Vote pour le maire en cours", sent)
self.assertIn("Vote des loups en cours", sent)
self.assertIn("zoopla", sent)
self.assertIn("zooplo", sent)
self.assertIn("zoopli", sent)
self.assertIn("Aucune action en cours", sent)
# all votes, one action but closed
bdd.BaseAction(slug="ouiZ",
trigger_debut=bdd.ActionTrigger.perma,
trigger_fin=bdd.ActionTrigger.perma).add()
action = bdd.Action(joueur=joueur, _base_slug="ouiZ")
action.add()
ctx = mock_discord.get_ctx(menu, _caller_id=1)
await ctx.invoke()
ctx.assert_sent("Aucune action en cours")
# all votes, one action
action.decision_ = "neIn"
ctx = mock_discord.get_ctx(menu, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
sent = ctx.send.call_args.args[0]
self.assertIn("Action en cours", sent)
self.assertIn("ouiZ", sent)
self.assertIn("neIn", sent)
# all votes, two actions
bdd.BaseAction(slug="JaJaJa",
trigger_debut=bdd.ActionTrigger.mot_mjs,
trigger_fin=bdd.ActionTrigger.perma).add()
bdd.Action(joueur=joueur, _base_slug="JaJaJa", decision_="o0ps").add()
ctx = mock_discord.get_ctx(menu, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
sent = ctx.send.call_args.args[0]
self.assertIn("Action en cours", sent)
self.assertIn("JaJaJa", sent)
self.assertIn("o0ps", sent)
async def test_annoncemort(self, as_patch):
"""Unit tests for !annoncemort command."""
# async def annoncemort(self, ctx, *, victime=None)
annoncemort = self.cog.annoncemort
mock_bdd.add_campsroles(10, 10)
joueurs = [
bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
statut=bdd.Statut.vivant,
_role_slug="role1"),
bdd.Joueur(discord_id=2,
chan_id_=21,
nom="Joueur2",
chambre="ch2",
statut=bdd.Statut.vivant),
bdd.Joueur(discord_id=3,
chan_id_=31,
nom="Joueur3",
statut=bdd.Statut.mort,
_role_slug="role3",
_camp_slug="camp3"),
bdd.Joueur(discord_id=4,
chan_id_=41,
nom="Joueur4",
chambre="ch 4",
statut=bdd.Statut.mort),
bdd.Joueur(discord_id=5,
chan_id_=51,
nom="Joueur5",
statut=bdd.Statut.MV,
_role_slug="role5"),
bdd.Joueur(discord_id=6,
chan_id_=61,
nom="Joueur6",
statut=bdd.Statut.immortel,
_role_slug="role3"),
]
bdd.Joueur.add(*joueurs)
# victime = None, correct "Joueur3", role ok, abort
ctx = mock_discord.get_ctx(annoncemort)
with mock_discord.interact(
("wait_for_message_here", mock_discord.message(ctx, "bzz")),
("wait_for_message_here", mock_discord.message(ctx, "Joueur3")),
("yes_no", True), # rôle à afficher
("wait_for_message_here", mock_discord.message(ctx, "oui")),
("yes_no", False), # abort
):
await ctx.invoke(cog=self.cog)
ctx.assert_sent("Qui", "Aucune entrée trouvée", "Rôle à afficher",
"Contexte", "Ça part", "Mission aborted")
as_patch.assert_not_called()
# victime = "Joueur3", role ok, proceed
ctx = mock_discord.get_ctx(annoncemort, victime="Joueur3")
with mock_discord.interact(
("yes_no", True), # rôle à afficher
("wait_for_message_here", mock_discord.message(ctx, "oui")),
("yes_no", True), # proceed
):
await ctx.invoke(cog=self.cog)
ctx.assert_sent("Rôle à afficher", "Contexte", "Ça part",
"c'est parti")
as_patch.assert_called_once()
self.assertIn("quelque chose", as_patch.call_args.args[0])
embed = as_patch.call_args.kwargs["embed"]
self.assertIn("Joueur3", embed.title)
self.assertIn("Role3", embed.title)
self.assertIn("oui", embed.description)
self.assertEqual(discord.Embed.Empty, embed.thumbnail.url)
# standard role: no emoji
as_patch.reset_mock()
# victime = "Joueur3", role ok, proceed + emoji
ctx = mock_discord.get_ctx(annoncemort, victime="Joueur3")
emoji3 = mock.NonCallableMock(discord.Emoji)
emoji3.configure_mock(name="emoji3", url="bzooop")
_emojis = config.guild.emojis
config.guild.emojis = [emoji3]
with mock_discord.interact(
("yes_no", True), # rôle à afficher
("wait_for_message_here", mock_discord.message(ctx, "oui")),
("yes_no", True), # proceed
):
await ctx.invoke(cog=self.cog)
config.guild.emojis = _emojis
ctx.assert_sent("Rôle à afficher", "Contexte", "Ça part",
"c'est parti")
as_patch.assert_called_once()
self.assertIn("quelque chose", as_patch.call_args.args[0])
embed = as_patch.call_args.kwargs["embed"]
self.assertIn("Joueur3", embed.title)
self.assertIn("Role3", embed.title)
self.assertIn("oui", embed.description)
self.assertEqual("bzooop", embed.thumbnail.url)
as_patch.reset_mock()
# victime = "Joueur5" (MV), role ok no MV, proceed
ctx = mock_discord.get_ctx(annoncemort, victime="Joueur5")
with mock_discord.interact(
("yes_no", True), # rôle à afficher
("yes_no", False), # afficher la MVance
("wait_for_message_here", mock_discord.message(ctx, "oui")),
("yes_no", True), # proceed
):
await ctx.invoke(cog=self.cog)
ctx.assert_sent("Rôle à afficher", "Annoncer la mort-vivance",
"Contexte", "Ça part", "c'est parti")
as_patch.assert_called_once()
self.assertIn("quelque chose", as_patch.call_args.args[0])
embed = as_patch.call_args.kwargs["embed"]
self.assertIn("Joueur5", embed.title)
self.assertIn("Role5", embed.title)
self.assertNotIn("Mort-Vivant", embed.title)
self.assertIn("oui", embed.description)
as_patch.reset_mock()
# victime = "Joueur5" (MV), role ok no MV, proceed
ctx = mock_discord.get_ctx(annoncemort, victime="Joueur5")
with mock_discord.interact(
("yes_no", True), # rôle à afficher
("yes_no", True), # afficher la MVance
("wait_for_message_here", mock_discord.message(ctx, "oui")),
("yes_no", True), # proceed
):
await ctx.invoke(cog=self.cog)
ctx.assert_sent("Rôle à afficher", "Annoncer la mort-vivance",
"Contexte", "Ça part", "c'est parti")
as_patch.assert_called_once()
self.assertIn("quelque chose", as_patch.call_args.args[0])
embed = as_patch.call_args.kwargs["embed"]
self.assertIn("Joueur5", embed.title)
self.assertIn("Role5", embed.title)
self.assertIn("Mort-Vivant", embed.title)
self.assertIn("oui", embed.description)
as_patch.reset_mock()
role_village = bdd.Role(slug="")
# victime = "Joueur3", role not ok usoab, proceed
ctx = mock_discord.get_ctx(annoncemort, victime="Joueur3")
with mock_discord.interact(
("yes_no", False), # rôle à afficher
("wait_for_message_here", mock_discord.message(ctx, "RolZZZ")),
("wait_for_react_clic",
mock.NonCallableMock(discord.Emoji, url="bzooop")),
("wait_for_message_here", mock_discord.message(ctx, "oui")),
("yes_no", True), # proceed
):
await ctx.invoke(cog=self.cog)
ctx.assert_sent("Rôle à afficher", "Rôle à afficher", "Camp",
"Contexte", "Ça part", "c'est parti")
as_patch.assert_called_once()
self.assertIn("quelque chose", as_patch.call_args.args[0])
embed = as_patch.call_args.kwargs["embed"]
self.assertIn("Joueur3", embed.title)
self.assertIn("RolZZZ", embed.title)
self.assertIn("oui", embed.description)
self.assertEqual("bzooop", embed.thumbnail.url)
as_patch.reset_mock()
async def test_open_action(self, log_patch, ca_patch):
"""Unit tests for gestion_actions.open_action function."""
# async def open_action(action)
open_action = gestion_actions.open_action
mock_bdd.add_campsroles()
j1 = bdd.Joueur(discord_id=1, chan_id_=11, nom="Joueur1",
role_actif=True)
j1.add()
# test préliminaire 1 - en cooldown, non temporel
ba1 = bdd.BaseAction(slug="ba1")
ba1.add()
act1 = bdd.Action(base=ba1, joueur=j1, cooldown=3)
act1.add()
with mock_discord.mock_members_and_chans(j1):
await open_action(act1)
self.assertEqual(act1.cooldown, 2)
log_patch.assert_called_once()
self.assertIn(repr(act1), log_patch.call_args.args[0])
self.assertIn("en cooldown", log_patch.call_args.args[0])
self.assertEqual(bdd.Tache.query.all(), [])
ca_patch.assert_not_called()
log_patch.reset_mock()
# test préliminaire 2 - en cooldown, temporel
ba2 = bdd.BaseAction(slug="ba2",
trigger_debut=bdd.ActionTrigger.temporel,
heure_debut=datetime.time(15, 2))
ba2.add()
act2 = bdd.Action(id=23, base=ba2, joueur=j1, cooldown=3)
act2.add()
with mock_discord.mock_members_and_chans(j1):
await open_action(act2)
self.assertEqual(act2.cooldown, 2)
log_patch.assert_called_once()
self.assertIn(repr(act2), log_patch.call_args.args[0])
self.assertIn("en cooldown", log_patch.call_args.args[0])
self.assertEqual(len(bdd.Tache.query.all()), 1)
tache = bdd.Tache.query.one()
self.assertEqual(tache.timestamp.time(), datetime.time(15, 2))
self.assertEqual(tache.commande, "!open 23")
self.assertEqual(tache.action, act2)
log_patch.reset_mock()
ca_patch.assert_not_called()
tache.delete()
# test préliminaire 3 - role non actif, non temporel
j2 = bdd.Joueur(discord_id=2, chan_id_=21, nom="Joueur2",
role_actif=False)
j2.add()
act3 = bdd.Action(id=24, base=ba1, joueur=j2, cooldown=0)
act3.add()
with mock_discord.mock_members_and_chans(j2):
await open_action(act3)
self.assertEqual(act3.cooldown, 0)
log_patch.assert_called_once()
self.assertIn(repr(act3), log_patch.call_args.args[0])
self.assertIn("role_actif == False", log_patch.call_args.args[0])
self.assertEqual(bdd.Tache.query.all(), [])
ca_patch.assert_not_called()
log_patch.reset_mock()
# test préliminaire 4 - role non actif, temporel
act4 = bdd.Action(id=25, base=ba2, joueur=j2, cooldown=0)
act4.add()
with mock_discord.mock_members_and_chans(j2):
await open_action(act4)
self.assertEqual(act4.cooldown, 0)
log_patch.assert_called_once()
self.assertIn(repr(act4), log_patch.call_args.args[0])
self.assertIn("role_actif == False", log_patch.call_args.args[0])
self.assertEqual(len(bdd.Tache.query.all()), 1)
tache = bdd.Tache.query.one()
self.assertEqual(tache.timestamp.time(), datetime.time(15, 2))
self.assertEqual(tache.commande, "!open 25")
self.assertEqual(tache.action, act4)
log_patch.reset_mock()
ca_patch.assert_not_called()
tache.delete()
# test préliminaire 5 - action automatique, non temporelle
ba3 = bdd.BaseAction(slug="ba3",
trigger_debut=bdd.ActionTrigger.perma,
trigger_fin=bdd.ActionTrigger.auto)
ba3.add()
act5 = bdd.Action(id=27, base=ba3, joueur=j1, cooldown=0)
act5.add()
with mock_discord.mock_members_and_chans(j1):
await open_action(act5)
self.assertEqual(act5.cooldown, 0)
log_patch.assert_called_once()
self.assertIn(repr(act5), log_patch.call_args.args[0])
self.assertIn("automatique", log_patch.call_args.args[0])
self.assertEqual(bdd.Tache.query.all(), [])
ca_patch.assert_called_once_with(act5)
log_patch.reset_mock()
ca_patch.reset_mock()
# test préliminaire 6 - action automatique, temporelle
ba4 = bdd.BaseAction(slug="ba4",
trigger_debut=bdd.ActionTrigger.temporel,
heure_debut=datetime.time(15, 2),
trigger_fin=bdd.ActionTrigger.auto)
ba4.add()
act6 = bdd.Action(id=28, base=ba4, joueur=j1, cooldown=0)
act6.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await open_action(act6)
self.assertEqual(act6.cooldown, 0)
log_patch.assert_called_once()
self.assertIn("ba4", log_patch.call_args.args[0])
self.assertIn("Joueur1", log_patch.call_args.args[0])
self.assertIn("pas vraiment automatique", log_patch.call_args.args[0])
self.assertIn(str(config.Role.mj.mention), log_patch.call_args.args[0])
self.assertIn(str(chan.mention), log_patch.call_args.args[0])
self.assertEqual(bdd.Tache.query.all(), [])
ca_patch.assert_called_once_with(act6)
log_patch.reset_mock()
ca_patch.reset_mock()
# --- fin des tests préliminaires
# fin hors temp/delta/perma, déjà ouverte
ba5 = bdd.BaseAction(slug="ba5",
trigger_debut=bdd.ActionTrigger.open_cond,
trigger_fin=bdd.ActionTrigger.close_cond)
ba5.add()
act7 = bdd.Action(base=ba5, joueur=j1, decision_="rien")
act7.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await open_action(act7)
mock_discord.assert_sent(chan, [
"tu peux utiliser quand tu le souhaites", "ba5", "!action",
])
mock_discord.assert_not_sent(chan, "tu as jusqu'à")
self.assertEqual(act7.decision_, "rien")
chan.send.return_value.add_reaction.assert_called_once_with(
config.Emoji.action
)
self.assertEqual(bdd.Tache.query.all(), [])
log_patch.assert_not_called()
ca_patch.assert_not_called()
# fin hors temp/delta/perma, fermée
ba6 = bdd.BaseAction(slug="ba6",
trigger_debut=bdd.ActionTrigger.open_cond,
trigger_fin=bdd.ActionTrigger.close_cond)
ba6.add()
act8 = bdd.Action(id=30, base=ba6, joueur=j1, decision_=None)
act8.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await open_action(act8)
mock_discord.assert_sent(chan, [
"Tu peux maintenant utiliser", "ba6", "!action",
])
mock_discord.assert_not_sent(chan, "tu as jusqu'à")
chan.send.return_value.add_reaction.assert_called_once_with(
config.Emoji.action
)
self.assertEqual(act8.decision_, "rien")
self.assertEqual(bdd.Tache.query.all(), [])
log_patch.assert_not_called()
ca_patch.assert_not_called()
# fin temp, déjà ouverte
ba7 = bdd.BaseAction(slug="ba7",
trigger_debut=bdd.ActionTrigger.open_cond,
trigger_fin=bdd.ActionTrigger.temporel,
heure_fin=datetime.time(15, 2))
ba7.add()
act9 = bdd.Action(id=31, base=ba7, joueur=j1, decision_="rien")
act9.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await open_action(act9)
mock_discord.assert_sent(chan, [
"tu peux utiliser quand tu le souhaites", "ba7", "!action",
f"Tu as jusqu'à {datetime.time(15, 2)}"
])
chan.send.return_value.add_reaction.assert_called_once_with(
config.Emoji.action
)
self.assertEqual(act9.decision_, "rien")
taches = bdd.Tache.query.all()
self.assertEqual(len(taches), 2)
self.assertEqual([tache.action for tache in taches], [act9]*2)
self.assertEqual(
{(tache.commande, tache.timestamp.time()) for tache in taches},
{("!close 31", datetime.time(15, 2)),
("!remind 31", datetime.time(14, 32))}
)
bdd.Tache.delete(*taches)
log_patch.assert_not_called()
ca_patch.assert_not_called()
# fin temp, fermée
ba8 = bdd.BaseAction(slug="ba8",
trigger_debut=bdd.ActionTrigger.open_cond,
trigger_fin=bdd.ActionTrigger.temporel,
heure_fin=datetime.time(15, 2))
ba8.add()
act10 = bdd.Action(id=32, base=ba8, joueur=j1, decision_=None)
act10.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await open_action(act10)
mock_discord.assert_sent(chan, [
"Tu peux maintenant utiliser", "ba8", "!action",
f"Tu as jusqu'à {datetime.time(15, 2)}"
])
self.assertEqual(act10.decision_, "rien")
chan.send.return_value.add_reaction.assert_called_once_with(
config.Emoji.action
)
taches = bdd.Tache.query.all()
self.assertEqual(len(taches), 2)
self.assertEqual([tache.action for tache in taches], [act10]*2)
self.assertEqual(
{(tache.commande, tache.timestamp.time()) for tache in taches},
{("!close 32", datetime.time(15, 2)),
("!remind 32", datetime.time(14, 32))}
)
bdd.Tache.delete(*taches)
log_patch.assert_not_called()
ca_patch.assert_not_called()
# fin delta (fermée)
ba9 = bdd.BaseAction(slug="ba9",
trigger_debut=bdd.ActionTrigger.open_cond,
trigger_fin=bdd.ActionTrigger.delta,
heure_fin=datetime.time(1, 10, 7))
ba9.add()
act11 = bdd.Action(id=33, base=ba9, joueur=j1, decision_=None)
act11.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
with freezegun.freeze_time(datetime.datetime(1, 1, 1, 16, 28, 4)):
await open_action(act11)
mock_discord.assert_sent(chan, [
"Tu peux maintenant utiliser", "ba9", "!action",
f"Tu as jusqu'à {datetime.time(17, 38, 11)}"
])
self.assertEqual(act11.decision_, "rien")
chan.send.return_value.add_reaction.assert_called_once_with(
config.Emoji.action
)
taches = bdd.Tache.query.all()
self.assertEqual(len(taches), 2)
self.assertEqual([tache.action for tache in taches], [act11]*2)
self.assertEqual(
{(tache.commande, tache.timestamp.time()) for tache in taches},
{("!close 33", datetime.time(17, 38, 11)),
("!remind 33", datetime.time(17, 8, 11))}
)
bdd.Tache.delete(*taches)
log_patch.assert_not_called()
ca_patch.assert_not_called()
# fin perma (fermée) - WE d'abord
ba10 = bdd.BaseAction(slug="ba10",
trigger_debut=bdd.ActionTrigger.open_cond,
trigger_fin=bdd.ActionTrigger.perma)
ba10.add()
act12 = bdd.Action(id=34, base=ba10, joueur=j1, decision_=None)
act12.add()
with mock.patch("lgrez.blocs.tools.next_occurence",
return_value=datetime.datetime(1, 1, 1, 16, 28, 4)), \
mock.patch("lgrez.blocs.tools.debut_pause",
return_value=datetime.datetime(1, 1, 1, 15, 28, 4)), \
mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await open_action(act12)
mock_discord.assert_sent(chan, [
"Tu peux maintenant utiliser", "ba10", "!action",
])
self.assertEqual(act12.decision_, "rien")
mock_discord.assert_not_sent(chan, "Tu as jusqu'à",)
chan.send.return_value.add_reaction.assert_called_once_with(
config.Emoji.action
)
self.assertEqual(len(bdd.Tache.query.all()), 1)
tache = bdd.Tache.query.one()
self.assertEqual(tache.action, act12)
self.assertEqual(tache.commande, "!close 34")
self.assertEqual(tache.timestamp.time(), datetime.time(15, 28, 4))
tache.delete()
log_patch.assert_not_called()
ca_patch.assert_not_called()
# fin perma (fermée) - prochaine ouverture d'abord
ba11 = bdd.BaseAction(slug="ba11",
trigger_debut=bdd.ActionTrigger.open_cond,
trigger_fin=bdd.ActionTrigger.perma)
ba11.add()
act13 = bdd.Action(id=35, base=ba11, joueur=j1, decision_=None)
act13.add()
with mock.patch("lgrez.blocs.tools.next_occurence",
return_value=datetime.datetime(1, 1, 1, 16, 28, 4)), \
mock.patch("lgrez.blocs.tools.debut_pause",
return_value=datetime.datetime(1, 1, 1, 17, 28, 4)), \
mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await open_action(act13)
mock_discord.assert_sent(chan, [
"Tu peux maintenant utiliser", "ba11", "!action",
])
self.assertEqual(act13.decision_, "rien")
mock_discord.assert_not_sent(chan, "Tu as jusqu'à",)
chan.send.return_value.add_reaction.assert_called_once_with(
config.Emoji.action
)
self.assertEqual(len(bdd.Tache.query.all()), 1)
tache = bdd.Tache.query.one()
self.assertEqual(tache.action, act13)
self.assertEqual(tache.commande, "!open 35")
self.assertEqual(tache.timestamp.time(), datetime.time(16, 28, 4))
tache.delete()
log_patch.assert_not_called()
ca_patch.assert_not_called()
async def test_vivants_morts(self):
"""Unit tests for !vivants and !morts commands."""
# async def vivants(self, ctx)
# async def morts(self, ctx)
vivants = self.cog.vivants
morts = self.cog.morts
# no players
ctx = mock_discord.get_ctx(vivants)
await ctx.invoke()
ctx.send.assert_called_once()
ctx = mock_discord.get_ctx(morts)
await ctx.invoke()
ctx.send.assert_called_once()
# vivants only
mock_bdd.add_campsroles()
bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
statut=bdd.Statut.vivant).add()
bdd.Joueur(discord_id=2,
chan_id_=21,
nom="Joueur2",
chambre="ch2",
statut=bdd.Statut.vivant).add()
ctx = mock_discord.get_ctx(vivants)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("Joueur1", ctx.send.call_args.args[0])
self.assertIn("Joueur2", ctx.send.call_args.args[0])
self.assertIn("ch2", ctx.send.call_args.args[0])
ctx = mock_discord.get_ctx(morts)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertNotIn("Joueur1", ctx.send.call_args.args[0])
# all status
bdd.Joueur(discord_id=3,
chan_id_=31,
nom="Joueur3",
statut=bdd.Statut.mort).add()
bdd.Joueur(discord_id=4,
chan_id_=41,
nom="Joueur4",
chambre="ch4",
statut=bdd.Statut.mort).add()
bdd.Joueur(discord_id=5,
chan_id_=51,
nom="Joueur5",
statut=bdd.Statut.MV).add()
bdd.Joueur(discord_id=6,
chan_id_=61,
nom="Joueur6",
statut=bdd.Statut.immortel).add()
ctx = mock_discord.get_ctx(vivants)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertNotIn("Joueur3", ctx.send.call_args.args[0])
self.assertNotIn("Joueur4", ctx.send.call_args.args[0])
self.assertNotIn("ch4", ctx.send.call_args.args[0])
self.assertIn("Joueur5", ctx.send.call_args.args[0])
self.assertIn("Joueur6", ctx.send.call_args.args[0])
ctx = mock_discord.get_ctx(morts)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("Joueur3", ctx.send.call_args.args[0])
self.assertIn("Joueur4", ctx.send.call_args.args[0])
self.assertNotIn("ch4", ctx.send.call_args.args[0])
self.assertNotIn("Joueur5", ctx.send.call_args.args[0])
self.assertNotIn("Joueur6", ctx.send.call_args.args[0])
# more players
for i in range(100):
bdd.Joueur(discord_id=100 + i,
chan_id_=i,
nom=f"Joueur{100+i}",
chambre=f"ch{100+i}",
statut=bdd.Statut.vivant).add()
bdd.Joueur(discord_id=200 + i,
chan_id_=i,
nom=f"Joueur{200+i}",
statut=bdd.Statut.mort).add()
ctx = mock_discord.get_ctx(vivants)
await ctx.invoke()
ctx.send.assert_called()
sent = "\n".join(call.args[0] for call in ctx.send.call_args_list)
for i in range(100):
self.assertIn(f"Joueur{100+i}", sent)
self.assertIn(f"ch{100+i}", sent)
ctx = mock_discord.get_ctx(morts)
await ctx.invoke()
ctx.send.assert_called()
sent = "\n".join(call.args[0] for call in ctx.send.call_args_list)
for i in range(100):
self.assertIn(f"Joueur{200+i}", sent)
async def test_voteloups(self, export_patch):
"""Unit tests for !voteloups command."""
# async def voteloups(self, ctx, *, cible=None)
voteloups = self.cog.voteloups
mock_bdd.add_campsroles()
joueur = bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
votant_loups=False,
vote_loups_="oh")
joueur.add()
# votant_loups False
ctx = mock_discord.get_ctx(voteloups, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("pas autorisé", ctx.send.call_args.args[0])
export_patch.assert_not_called()
# no voteloups
joueur.votant_loups = True
joueur.vote_loups_ = None
joueur.update()
ctx = mock_discord.get_ctx(voteloups, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("pas de vote", ctx.send.call_args.args[0].lower())
export_patch.assert_not_called()
# closed during cible choice
joueur.vote_loups_ = "oh"
joueur.update()
cible = bdd.Joueur(discord_id=2, chan_id_=21, nom="Joueur2")
cible.add()
ctx = mock_discord.get_ctx(voteloups, _caller_id=1)
def close_vote(*args, **kwargs):
joueur.vote_loups_ = None
joueur.update()
return ctx.new_message("Joueur2")
with mock_discord.interact(("wait_for_message_here", close_vote)):
# close voteloups and return cible
await ctx.invoke()
self.assertEqual(ctx.send.call_count, 2)
self.assertIn("a fermé entre temps", ctx.send.call_args.args[0])
export_patch.assert_not_called()
# ok
joueur.vote_loups_ = "oh" # reopen voteloups
joueur.update()
ctx = mock_discord.get_ctx(voteloups, cible="Joueur2", _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("Joueur2", ctx.send.call_args.args[0])
self.assertIn("bien pris en compte", ctx.send.call_args.args[0])
self.assertEqual(joueur.vote_loups_, "Joueur2")
export_patch.assert_called_once_with("loups", joueur)
export_patch.reset_mock()
# ok, cible not specified
joueur.vote_loups_ = "oh" # reset voteloups
joueur.update()
ctx = mock_discord.get_ctx(voteloups, _caller_id=1)
with mock_discord.interact(
("wait_for_message_here", ctx.new_message("zzz")),
("wait_for_message_here", ctx.new_message("zzz")),
("wait_for_message_here", ctx.new_message("Joueur2"))):
await ctx.invoke()
self.assertIn("Joueur2", ctx.send.call_args.args[0])
self.assertIn("bien pris en compte", ctx.send.call_args.args[0])
self.assertEqual(joueur.vote_loups_, "Joueur2")
export_patch.assert_called_once_with("loups", joueur)
export_patch.reset_mock()
async def test_action(self, export_patch, ca_patch):
"""Unit tests for !action command."""
# async def action(self, ctx, *, decision=None)
action = self.cog.action
mock_bdd.add_campsroles()
joueur = bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
role_actif=False)
joueur.add()
# role_actif False
ctx = mock_discord.get_ctx(action, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("ne peux pas utiliser", ctx.send.call_args.args[0])
export_patch.assert_not_called()
ca_patch.assert_not_called()
# no actions
joueur.role_actif = True
joueur.update()
ctx = mock_discord.get_ctx(action, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("Aucune action en cours", ctx.send.call_args.args[0])
export_patch.assert_not_called()
ca_patch.assert_not_called()
# 1 closed action
bdd.BaseAction(slug="ouiZ").add()
action1 = bdd.Action(joueur=joueur, _base_slug="ouiZ")
action1.add()
ctx = mock_discord.get_ctx(action, _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("Aucune action en cours", ctx.send.call_args.args[0])
export_patch.assert_not_called()
ca_patch.assert_not_called()
# 1 open action and decision_
action1.decision_ = "oh"
action1.update()
ctx = mock_discord.get_ctx(action, decision="boo", _caller_id=1)
await ctx.invoke()
ctx.send.assert_called_once()
self.assertIn("boo", ctx.send.call_args.args[0])
self.assertIn("bien prise en compte", ctx.send.call_args.args[0])
self.assertIn("ouiZ", ctx.send.call_args.args[0])
self.assertEqual(action1.decision_, "boo")
export_patch.assert_called_once_with("action", joueur)
export_patch.reset_mock()
ca_patch.assert_not_called()
# 1 open action and no decision_
action1.decision_ = "oh"
action1.update()
ctx = mock_discord.get_ctx(action, _caller_id=1)
with mock_discord.interact(
("wait_for_message_here", ctx.new_message("boo"))):
await ctx.invoke()
ctx.send.assert_called()
self.assertIn("boo", ctx.send.call_args.args[0])
self.assertIn("bien prise en compte", ctx.send.call_args.args[0])
self.assertIn("ouiZ", ctx.send.call_args.args[0])
self.assertEqual(action1.decision_, "boo")
export_patch.assert_called_once_with("action", joueur)
export_patch.reset_mock()
ca_patch.assert_not_called()
# 1 open INSTANT action and abort
action1.decision_ = "oh"
action1.base.instant = True
action1.update()
ctx = mock_discord.get_ctx(action, decision="boo", _caller_id=1)
with mock_discord.interact(("yes_no", False)):
# abort (answer "no" at instant warning)
await ctx.invoke()
ctx.send.assert_called()
calls = ctx.send.call_args_list
self.assertIn("conséquence instantanée", calls[0].args[0])
self.assertIn("Ça part ?", calls[0].args[0])
self.assertIn("aborted", calls[1].args[0])
self.assertEqual(action1.decision_, "oh")
export_patch.assert_not_called()
ca_patch.assert_not_called()
# 1 open INSTANT action and proceed
ctx = mock_discord.get_ctx(action, decision="boo", _caller_id=1)
with mock_discord.interact(("yes_no", True)):
# proceed (answer "yes" at instant warning)
await ctx.invoke()
ctx.assert_sent(
"Attention",
[str(config.Role.mj.mention), "conséquence instantanée"])
self.assertEqual(action1.decision_, "boo")
export_patch.assert_called_once_with("action", joueur)
export_patch.reset_mock()
ca_patch.assert_called_once_with(action1)
ca_patch.reset_mock()
# 1 open action and closed during decision choice
action1.decision_ = "oh"
action1.base.instant = False
action1.update()
def close_action(*args, **kwargs):
action1.decision_ = None
action1.update()
return ctx.new_message("boo")
ctx = mock_discord.get_ctx(action, _caller_id=1)
with mock_discord.interact(("wait_for_message_here", close_action)):
# close action and return decision
await ctx.invoke()
ctx.send.assert_called()
self.assertIn("a fermé entre temps", ctx.send.call_args.args[0])
export_patch.assert_not_called()
ca_patch.assert_not_called()
# 2 open actions and decision_: ask
action1.decision_ = "oh"
action1.update()
bdd.BaseAction(slug="nonZ").add()
action2 = bdd.Action(joueur=joueur, _base_slug="nonZ", decision_="uh")
action2.add()
ctx = mock_discord.get_ctx(action, decision="ih", _caller_id=1)
with mock_discord.interact(
("choice", 2), ("wait_for_message_here", ctx.new_message("boo"))):
await ctx.invoke()
ctx.send.assert_called()
calls = ctx.send.call_args_list
self.assertIn("ouiZ", calls[0].args[0])
self.assertIn("nonZ", calls[0].args[0])
self.assertIn("Pour laquelle", calls[0].args[0])
self.assertIn("nonZ", calls[1].args[0])
self.assertIn("veux-tu faire", calls[1].args[0])
self.assertIn("boo", calls[2].args[0])
self.assertIn("bien prise en compte", calls[2].args[0])
self.assertIn("nonZ", calls[2].args[0])
self.assertEqual(action1.decision_, "oh")
self.assertEqual(action2.decision_, "boo")
export_patch.assert_called_once_with("action", joueur)
ca_patch.assert_not_called()
async def test_close_action(self, da_patch):
"""Unit tests for gestion_actions.close_action function."""
# async def close_action(action)
close_action = gestion_actions.close_action
mock_bdd.add_campsroles()
j1 = bdd.Joueur(discord_id=1, chan_id_=11, nom="Joueur1")
j1.add()
# pas de décision, no base_cooldown, no temporel/perma
ba1 = bdd.BaseAction(slug="ba1", instant=False, base_cooldown=0,
trigger_debut=bdd.ActionTrigger.open_cond)
ba1.add()
act1 = bdd.Action(base=ba1, joueur=j1, decision_="rien")
act1.add()
await close_action(act1)
self.assertIsNone(act1.decision_)
self.assertEqual(bdd.Tache.query.all(), [])
da_patch.assert_not_called()
# pas de décision, base_cooldown = 4, no temporel/perma
ba2 = bdd.BaseAction(slug="ba2", instant=False, base_cooldown=4,
trigger_debut=bdd.ActionTrigger.open_cond)
ba2.add()
act2 = bdd.Action(base=ba2, joueur=j1, cooldown=0, decision_="rien")
act2.add()
await close_action(act2)
self.assertIsNone(act2.decision_)
self.assertEqual(act2.cooldown, 4)
self.assertEqual(bdd.Tache.query.all(), [])
da_patch.assert_not_called()
# pas de décision, no base_cooldown, temporel
ba3 = bdd.BaseAction(slug="ba3", instant=False, base_cooldown=0,
trigger_debut=bdd.ActionTrigger.temporel,
heure_debut=datetime.time(15, 2))
ba3.add()
act3 = bdd.Action(id=3, base=ba3, joueur=j1, decision_="rien")
act3.add()
with mock.patch("lgrez.blocs.tools.next_occurence") as no_patch:
no_patch.return_value = datetime.datetime(1, 1, 1, 15, 2)
await close_action(act3)
no_patch.assert_called_once_with(datetime.time(15, 2))
self.assertIsNone(act3.decision_)
self.assertEqual(len(bdd.Tache.query.all()), 1)
tache = bdd.Tache.query.one()
self.assertEqual(tache.timestamp, no_patch.return_value)
self.assertEqual(tache.commande, "!open 3")
self.assertEqual(tache.action, act3)
tache.delete()
da_patch.assert_not_called()
# pas de décision, no base_cooldown, perma
ba4 = bdd.BaseAction(slug="ba4", instant=False, base_cooldown=0,
trigger_debut=bdd.ActionTrigger.perma)
ba4.add()
act4 = bdd.Action(id=4, base=ba4, joueur=j1, decision_="rien")
act4.add()
with mock.patch("lgrez.blocs.tools.fin_pause") as fp_patch:
fp_patch.return_value = datetime.datetime(1, 1, 1, 10, 4)
await close_action(act4)
fp_patch.assert_called_once()
self.assertIsNone(act4.decision_)
self.assertEqual(len(bdd.Tache.query.all()), 1)
tache = bdd.Tache.query.one()
self.assertEqual(tache.timestamp, fp_patch.return_value)
self.assertEqual(tache.commande, "!open 4")
self.assertEqual(tache.action, act4)
tache.delete()
da_patch.assert_not_called()
# décision, no base_cooldown, no temporel/perma, no charges ==> no diff
act11 = bdd.Action(base=ba1, joueur=j1, decision_="ach ja",
charges=None)
act11.add()
await close_action(act11)
self.assertIsNone(act11.decision_)
self.assertIsNone(act11.charges)
self.assertEqual(bdd.Tache.query.all(), [])
da_patch.assert_not_called()
# décision, no base_cooldown, no temporel/perma, 4 charges
act12 = bdd.Action(base=ba1, joueur=j1, decision_="ach ja", charges=4)
act12.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await close_action(act12)
self.assertIsNone(act12.decision_)
self.assertEqual(act12.charges, 3)
mock_discord.assert_sent(chan, "Il te reste 3 charge")
mock_discord.assert_not_sent(chan, "pour cette semaine")
self.assertEqual(bdd.Tache.query.all(), [])
da_patch.assert_not_called()
# décision, no base_cooldown, no temporel/perma, 4 charges, refill WE
ba1b = bdd.BaseAction(slug="ba1b", instant=False, base_cooldown=0,
trigger_debut=bdd.ActionTrigger.open_cond,
refill="weekends, other")
ba1b.add()
act13 = bdd.Action(base=ba1b, joueur=j1, decision_="ach ja", charges=4)
act13.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await close_action(act13)
self.assertIsNone(act13.decision_)
self.assertEqual(act13.charges, 3)
mock_discord.assert_sent(chan, "Il te reste 3 charge")
mock_discord.assert_sent(chan, "pour cette semaine")
self.assertEqual(bdd.Tache.query.all(), [])
da_patch.assert_not_called()
# décision, no base_cooldown, no temporel/perma, 1 charge
act14 = bdd.Action(id=37, base=ba1, joueur=j1, decision_="ach ja",
charges=1)
act14.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await close_action(act14)
da_patch.assert_called_once_with(act14) # deleted
mock_discord.assert_sent(chan, "Il te reste 0 charge")
mock_discord.assert_not_sent(chan, "pour cette semaine")
self.assertEqual(bdd.Tache.query.all(), [])
da_patch.reset_mock()
# décision, no base_cooldown, no temporel/perma, 1 charge, refill WE
act13 = bdd.Action(base=ba1b, joueur=j1, decision_="ach ja", charges=1)
act13.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await close_action(act13)
self.assertIsNone(act13.decision_)
self.assertEqual(act13.charges, 0) # not deleted
mock_discord.assert_sent(chan, "Il te reste 0 charge")
mock_discord.assert_sent(chan, "pour cette semaine")
self.assertEqual(bdd.Tache.query.all(), [])
da_patch.assert_not_called()
# décision, no base_cooldown, no temporel/perma, 1 charge, refill autre
ba1c = bdd.BaseAction(slug="ba1c", instant=False, base_cooldown=0,
trigger_debut=bdd.ActionTrigger.open_cond,
refill="brzzz")
ba1c.add()
act13 = bdd.Action(base=ba1c, joueur=j1, decision_="ach ja", charges=1)
act13.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await close_action(act13)
self.assertIsNone(act13.decision_)
self.assertEqual(act13.charges, 0) # not deleted
mock_discord.assert_sent(chan, "Il te reste 0 charge")
mock_discord.assert_not_sent(chan, "pour cette semaine")
self.assertEqual(bdd.Tache.query.all(), [])
da_patch.assert_not_called()
# deleted et plein d'autre trucs
batro = bdd.BaseAction(slug="batro", instant=False, base_cooldown=2,
trigger_debut=bdd.ActionTrigger.perma,
refill="brzzz")
act14 = bdd.Action(base=ba1, joueur=j1, decision_="ach ja", charges=1)
act14.add()
with mock_discord.mock_members_and_chans(j1):
chan = j1.private_chan
await close_action(act14)
da_patch.assert_called_once_with(act14) # deleted
mock_discord.assert_sent(chan, "Il te reste 0 charge")
mock_discord.assert_not_sent(chan, "pour cette semaine")
self.assertEqual(bdd.Tache.query.all(), [])
da_patch.reset_mock()
async def test_send(self):
"""Unit tests for !send command."""
# async def send(self, ctx, cible, *, message)
send = self.cog.send
mock_bdd.add_campsroles(10, 10)
joueurs = [
bdd.Joueur(discord_id=1,
chan_id_=11,
nom="Joueur1",
statut=bdd.Statut.vivant,
_role_slug="role1",
votant_village=True,
votant_loups=False,
role_actif=False),
bdd.Joueur(discord_id=2,
chan_id_=21,
nom="Joueur2",
chambre="ch2",
statut=bdd.Statut.vivant,
votant_village=True,
votant_loups=False,
role_actif=False),
bdd.Joueur(discord_id=3,
chan_id_=31,
nom="Joueur3",
statut=bdd.Statut.mort,
_role_slug="role3",
_camp_slug="camp3",
votant_village=True,
votant_loups=False,
role_actif=True),
bdd.Joueur(discord_id=4,
chan_id_=41,
nom="Joueur4",
chambre="ch 4",
statut=bdd.Statut.mort,
votant_village=False,
votant_loups=False,
role_actif=True),
bdd.Joueur(discord_id=5,
chan_id_=51,
nom="Joueur 5",
statut=bdd.Statut.MV,
_camp_slug="camp3",
votant_village=False,
votant_loups=False,
role_actif=False),
bdd.Joueur(discord_id=6,
chan_id_=61,
nom="Joueur6",
statut=bdd.Statut.immortel,
_role_slug="role3",
votant_village=False,
votant_loups=True,
role_actif=False),
]
bdd.Joueur.add(*joueurs)
# cible = "all"
ctx = mock_discord.get_ctx(send, "all", message="ouizz")
with mock_discord.mock_members_and_chans(*joueurs):
chans = [joueur.private_chan for joueur in joueurs]
await ctx.invoke()
ctx.assert_sent("6 trouvé", "Fini")
for chan in chans:
chan.send.assert_called_once_with("ouizz")
# cible = "vivants"
ctx = mock_discord.get_ctx(send, "vivants", message="nonkk")
with mock_discord.mock_members_and_chans(*joueurs):
chans = [joueur.private_chan for joueur in joueurs]
await ctx.invoke()
ctx.assert_sent("3 trouvé", "Fini")
for i, chan in enumerate(chans):
if i in [0, 1, 4]:
chan.send.assert_called_once_with("nonkk")
else:
chan.send.assert_not_called()
# cible = "morts"
ctx = mock_discord.get_ctx(send, "morts", message="bzzk.!")
with mock_discord.mock_members_and_chans(*joueurs):
chans = [joueur.private_chan for joueur in joueurs]
await ctx.invoke()
ctx.assert_sent("2 trouvé", "Fini")
for i, chan in enumerate(chans):
if i in [2, 3]:
chan.send.assert_called_once_with("bzzk.!")
else:
chan.send.assert_not_called()
# cible = bat crit
ctx = mock_discord.get_ctx(send, "biz=oui", message="hmm")
with self.assertRaises(discord.ext.commands.UserInputError) as cm:
await ctx.invoke()
self.assertIn("critère 'biz' incorrect", cm.exception.args[0])
# cible = all crits
crits = {
"discord_id=3": [2],
"chan_id_=21": [1],
"nom=Joueur4": [3],
"nom=Joueur 5": [4],
"chambre=ch2": [1],
"chambre=ch 4": [3],
"statut=vivant": [0, 1],
"statut=mort": [2, 3],
"statut=MV": [4],
"statut=immortel": [5],
"role=role1": [0],
"role=role3": [2, 5],
"camp=camp3": [2, 4],
"votant_village=True": [0, 1, 2],
"votant_village=1": [0, 1, 2],
"votant_village=faux": [3, 4, 5],
"votant_loups=vrai": [5],
"votant_loups=0": [0, 1, 2, 3, 4],
"role_actif=True": [2, 3],
"role_actif=False": [0, 1, 4, 5],
}
for crit, ijs in crits.items():
ctx = mock_discord.get_ctx(send, crit, message="bakka")
with mock_discord.mock_members_and_chans(*joueurs):
chans = [joueur.private_chan for joueur in joueurs]
await ctx.invoke()
ctx.assert_sent(f"{len(ijs)} trouvé", "Fini")
for i, chan in enumerate(chans):
if i in ijs:
chan.send.assert_called_once_with("bakka")
else:
chan.send.assert_not_called()
# cible = non-existing joueur, correct
ctx = mock_discord.get_ctx(send, "gouzigouzi", message="oui")
with mock_discord.interact(
("wait_for_message_here", mock_discord.message(ctx, "krr")),
("wait_for_message_here", mock_discord.message(ctx, "Joueur2")),
):
with mock_discord.mock_members_and_chans(*joueurs):
chans = [joueur.private_chan for joueur in joueurs]
await ctx.invoke()
ctx.assert_sent("Aucune entrée trouvée", "Aucune entrée trouvée",
"1 trouvé", "Fini")
for i, chan in enumerate(chans):
if i == 1:
chan.send.assert_called_once_with("oui")
else:
chan.send.assert_not_called()
# cible = existing joueur, correct
ctx = mock_discord.get_ctx(send, "Joueur 5", message="oui")
with mock_discord.mock_members_and_chans(*joueurs):
chans = [joueur.private_chan for joueur in joueurs]
await ctx.invoke()
ctx.assert_sent("1 trouvé", "Fini")
for i, chan in enumerate(chans):
if i == 4:
chan.send.assert_called_once_with("oui")
else:
chan.send.assert_not_called()
# cible = all, test eval
ctx = mock_discord.get_ctx(
send,
"all",
message="Salut {member.mention}, tu t'appelles {joueur.role}, rôle "
"{joueur.role.nom}, camp {joueur.camp.nom}, chan {chan.name}")
with mock_discord.mock_members_and_chans(*joueurs):
members = [joueur.member for joueur in joueurs]
chans = [joueur.private_chan for joueur in joueurs]
await ctx.invoke()
ctx.assert_sent("6 trouvé", "Fini")
for joueur, chan, member in zip(joueurs, chans, members):
chan.send.assert_called_once_with(
f"Salut {member.mention}, tu t'appelles {joueur.role}, rôle "
f"{joueur.role.nom}, camp {joueur.camp.nom}, chan {chan.name}")
async def test_main(self, sleep_patch, reg_patch, newchan_patch):
"""Unit tests for inscription.main function."""
# async def main(member)
main = inscription.main
mock_bdd.add_campsroles()
joueur1 = bdd.Joueur(discord_id=1, chan_id_=11, nom="Joueur 1")
joueur1.add()
newchan_patch.return_value = mock_discord.chan("bzzt", id=798)
# Joueur inscrit en base
with mock_discord.mock_members_and_chans(joueur1):
member = joueur1.member
chan = joueur1.private_chan
await main(member)
chan.set_permissions.assert_called_once_with(member,
read_messages=True,
send_messages=True)
mock_discord.assert_sent(chan, f"{member.mention} tu es déjà inscrit")
reg_patch.assert_not_called()
newchan_patch.assert_not_called()
sleep_patch.assert_not_called()
joueur1.delete()
# Joueur en cours d'inscription -> abort
chan = mock_discord.chan("bzz", topic="123456")
config.guild.text_channels = [chan]
member = mock.Mock(discord.Member, id=123456)
with mock_discord.interact(("yes_no", False)):
await main(member)
chan.set_permissions.assert_called_once_with(member,
read_messages=True,
send_messages=True)
mock_discord.assert_sent(chan, f"{member.mention}, par ici",
f"Bienvenue {member.mention}",
f"finalisons ton inscription",
f"C'est bon pour toi ?", "Pas de soucis")
reg_patch.assert_not_called()
newchan_patch.assert_not_called()
sleep_patch.assert_called()
sleep_patch.reset_mock()
# Joueur arrivant -> abort
member = mock.Mock(discord.Member, id=145)
with mock_discord.interact(("yes_no", False)):
await main(member)
newchan_patch.assert_called_once_with(member)
chan = newchan_patch.return_value
mock_discord.assert_sent(chan, f"Bienvenue {member.mention}",
f"finalisons ton inscription",
f"C'est bon pour toi ?", "Pas de soucis")
reg_patch.assert_not_called()
newchan_patch.reset_mock()
sleep_patch.assert_called()
sleep_patch.reset_mock()
# Joueur arrivant -> ok -> name -> troll -> good name
# demande_chambre False
config.demande_chambre = False
member = mock.Mock(discord.Member, id=145)
member.top_role.__lt__ = lambda s, o: True # role < MJ
member.display_name = "Pr-Z N0 N"
with mock_discord.interact(
("yes_no", True),
("wait_for_message",
mock.NonCallableMock(discord.Message, content="préz")),
("wait_for_message",
mock.NonCallableMock(discord.Message, content="no n")),
("yes_no", False),
("wait_for_message",
mock.NonCallableMock(discord.Message, content="pr-z")),
("wait_for_message",
mock.NonCallableMock(discord.Message, content="n0 n")),
("yes_no", True),
):
await main(member)
newchan_patch.assert_called_once_with(member)
chan = newchan_patch.return_value
mock_discord.assert_sent(
chan, f"Bienvenue {member.mention}", "finalisons ton inscription",
f"C'est bon pour toi ?", ["Parfait", "prénom"], "prénom",
"nom de famille", "Préz No N", "prénom", "nom de famille",
"Pr-Z N0 N", "Je t'ai renommé", "Je t'inscris",
"Tu es maintenant inscrit", "quelques dernières choses",
"c'est tout bon")
chan.edit.assert_any_call(
name=f"{config.private_chan_prefix}Pr-Z N0 N")
member.edit.assert_called_once_with(nick="Pr-Z N0 N")
member.edit.reset_mock()
self.assertEqual(len(bdd.Joueur.query.all()), 1)
jr = bdd.Joueur.query.one()
self.assertEqual([
jr.discord_id, jr.chan_id_, jr.nom, jr.chambre, jr.statut, jr.role,
jr.camp, jr.votant_village, jr.votant_loups, jr.role_actif
], [
145, 798, "Pr-Z N0 N", None, bdd.Statut.vivant,
bdd.Role.default(),
bdd.Camp.default(), True, False, False
])
member.add_roles.assert_called_once_with(config.Role.joueur_en_vie)
chan.edit.assert_any_call(topic=mock.ANY)
reg_patch.assert_called_once_with(jr)
reg_patch.reset_mock()
newchan_patch.reset_mock()
sleep_patch.assert_called()
sleep_patch.reset_mock()
jr.delete()
# Joueur arrivant -> ok -> name -> chambre -> pas à la Rez
config.demande_chambre = True
member = mock.Mock(discord.Member, id=145)
member.top_role.__lt__ = lambda s, o: True # role < MJ
member.display_name = "Pr-Z N0 N"
with mock_discord.interact(
("yes_no", True),
("wait_for_message",
mock.NonCallableMock(discord.Message, content="pr-z")),
("wait_for_message",
mock.NonCallableMock(discord.Message, content="n0 n")),
("yes_no", True),
("yes_no", False),
):
await main(member)
newchan_patch.assert_called_once_with(member)
chan = newchan_patch.return_value
mock_discord.assert_sent(
chan, f"Bienvenue {member.mention}", "finalisons ton inscription",
f"C'est bon pour toi ?", ["Parfait", "prénom"], "prénom",
"nom de famille", "Pr-Z N0 N", "Je t'ai renommé",
"habites-tu à la Rez", "Je t'inscris", "Tu es maintenant inscrit",
"quelques dernières choses", "c'est tout bon")
chan.edit.assert_any_call(
name=f"{config.private_chan_prefix}Pr-Z N0 N")
member.edit.assert_called_once_with(nick="Pr-Z N0 N")
member.edit.reset_mock()
self.assertEqual(len(bdd.Joueur.query.all()), 1)
jr = bdd.Joueur.query.one()
self.assertEqual([
jr.discord_id, jr.chan_id_, jr.nom, jr.chambre, jr.statut, jr.role,
jr.camp, jr.votant_village, jr.votant_loups, jr.role_actif
], [
145, 798, "Pr-Z N0 N", config.chambre_mj, bdd.Statut.vivant,
bdd.Role.default(),
bdd.Camp.default(), True, False, False
])
member.add_roles.assert_called_once_with(config.Role.joueur_en_vie)
chan.edit.assert_any_call(topic=mock.ANY)
reg_patch.assert_called_once_with(jr)
reg_patch.reset_mock()
newchan_patch.reset_mock()
sleep_patch.assert_called()
sleep_patch.reset_mock()
jr.delete()
# Joueur arrivant -> ok -> name -> chambre -> à la Rez
config.demande_chambre = True
member = mock.Mock(discord.Member, id=145)
member.top_role.__lt__ = lambda s, o: True # role < MJ
member.display_name = "Pr-Z N0 N"
with mock_discord.interact(
("yes_no", True),
("wait_for_message",
mock.NonCallableMock(discord.Message, content="pr-z")),
("wait_for_message",
mock.NonCallableMock(discord.Message, content="n0 n")),
("yes_no", True),
("yes_no", True),
("wait_for_message",
mock.NonCallableMock(discord.Message, content="214")),
):
await main(member)
newchan_patch.assert_called_once_with(member)
chan = newchan_patch.return_value
mock_discord.assert_sent(
chan, f"Bienvenue {member.mention}", "finalisons ton inscription",
f"C'est bon pour toi ?", ["Parfait", "prénom"], "prénom",
"nom de famille", "Pr-Z N0 N", "Je t'ai renommé",
"habites-tu à la Rez", "quelle est ta chambre", "Je t'inscris",
"Tu es maintenant inscrit", "quelques dernières choses",
"c'est tout bon")
chan.edit.assert_any_call(
name=f"{config.private_chan_prefix}Pr-Z N0 N")
member.edit.assert_called_once_with(nick="Pr-Z N0 N")
member.edit.reset_mock()
self.assertEqual(len(bdd.Joueur.query.all()), 1)
jr = bdd.Joueur.query.one()
self.assertEqual([
jr.discord_id, jr.chan_id_, jr.nom, jr.chambre, jr.statut, jr.role,
jr.camp, jr.votant_village, jr.votant_loups, jr.role_actif
], [
145, 798, "Pr-Z N0 N", "214", bdd.Statut.vivant,
bdd.Role.default(),
bdd.Camp.default(), True, False, False
])
member.add_roles.assert_called_once_with(config.Role.joueur_en_vie)
chan.edit.assert_any_call(topic=mock.ANY)
reg_patch.assert_called_once_with(jr)
reg_patch.reset_mock()
newchan_patch.reset_mock()
sleep_patch.assert_called()
sleep_patch.reset_mock()
jr.delete()
