fix: Correction des bugs de typage et des tests unitaires manquants.

src/utils.py

@@ -1,6 +1,5 @@
 import math
 import string
-import sys
 from pathlib import Path
 from typing import Any, Dict, List, TypedDict
 
@@ -44,7 +43,7 @@ def est_dechiffre(texte:str) -> bool:
         Returns: 
             bool: déchiffrée ou non
     """
-    stats:dict=verifier_texte_dechiffre(texte)
+    stats:dict[str, Any] = verifier_texte_dechiffre(texte)
     pourcent=0
 
     # Les caractères imprimables constituent 50% de la validation du déchiffrement
@@ -81,7 +80,7 @@ def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
 
     #Statistiques sur le texte 
 
-    stats: dict = {
+    stats: dict[str, Any] = {
         'imprimable':0,
         'nombre_mots':0,
         'p_mots_valide':0,
@@ -137,8 +136,7 @@ def verifier_texte_dechiffre(texte: str) -> Dict[str, Any]:
             stats['p_mots_valide'] = 0.0
 
     except Exception:
-        tb=sys.exception().__traceback__
-        raise Exception().with_traceback(tb)
+        raise
 
 
     #Verifier la structure de ponctuation.

tests/test_analyzers.py

@@ -13,15 +13,19 @@ class AnalyzersTester(TestCase):
 
     def setUp(self):
         self.chemin_fichier_chiffre = "data/mission1.enc"
+        self.chemin_fichier_chiffre_invalide = "tests/fichiers_pour_tests/mission1_invalide.enc"
         self.wordlist = "keys/wordlist.txt"
         self.analyser = Aes_Cbc_Analyzer()
 
 
     def test_aes_cbc_identifier_algo(self):
         self.assertAlmostEqual(self.analyser.identifier_algo(self.chemin_fichier_chiffre), 1)
+        self.assertAlmostEqual(self.analyser.identifier_algo(self.chemin_fichier_chiffre_invalide), 0)
 
     def test_aes_cbc_filtrage_dict(self):
         self.assertIsInstance(self.analyser.filtrer_dictionnaire_par_indices(self.wordlist), list)
+        self.assertEqual(self.analyser.filtrer_dictionnaire_par_indices(self.wordlist), ["paris2024"])
+        self.assertEqual(self.analyser.filtrer_dictionnaire_par_indices("chemin_dohi.txt"), [])
 
     def test_generation_cles_candidate(self):
         self.assertIsInstance(self.analyser.generer_cles_candidates(self.wordlist), list)

tests/test_global.py

@@ -9,16 +9,12 @@
 
 """
 
-# Définition d'une fonction d'addition (+) pour les tests 
-def add(a,b):
-    return a+b
-
 class BetaTester(TestCase):
     #Définition de la méthode de test
     """ 
-        # La fonction doit être préfixé du mot test pour que le TestCase puisse le l'identifier en tant que méthode à tester (le snake_case ici devra être appliqué ici) 
+        # La fonction doit être préfixé du mot test pour que le TestCase puisse le l'identifier en tant que méthode à tester (le snake_case devra être appliqué ici) 
 
-        # En fonction du type de vérification que vous souhaitez effectué par rapport aux test les méthodes assert devront variés.
+        # En fonction du type de vérification que vous souhaitez effectuer par rapport aux test les méthodes assert devront varier.
         ex : * assertEqual() pour vérifier l'égalité. Dans le cas utilisé cette fonction vérifie si le retour de la fonction add correspond à la valeur 10
             * assertIn() pour vérifier si une variable est dans une iterable
             * assertIsInstance() pour vérifier le type de retour d'une variable ou fonction etc... (description des méthodes à l'appui)
@@ -30,9 +26,6 @@ class BetaTester(TestCase):
 
     """
 
-    def test_addition(self):
-        self.assertEqual(add(5,5),10)
-
 
     def test_verification_texte_dechiffre(self):
         resultat = verifier_texte_dechiffre("je talk !a mamamia:?")
@@ -43,7 +36,17 @@ def test_verification_texte_dechiffre(self):
         self.assertEqual(resultat['ponctuation_valide'], 50.0)
 
     def test_calcul_entropie(self) -> None:
-        self.assertGreater(calculer_entropie("aaaaaaaa"), 0)
+        chaine_repetitive = b"aaaaaaaa"
+        chaine_aleatoire = b"aze15io!"
+        chaine_vide = b""
+
+        entropie_chaine_repetitive = calculer_entropie(chaine_repetitive)
+        entropie_chaine_aleatoire = calculer_entropie(chaine_aleatoire)
+        entropie_chaine_vide = calculer_entropie(chaine_vide)
+
+        self.assertGreater(entropie_chaine_repetitive, 0)
+        self.assertEqual(entropie_chaine_vide, 0)
+        self.assertGreater(entropie_chaine_aleatoire, entropie_chaine_repetitive)
 
 
 if __name__ == '__main__':