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()