Mise en place des tests liés à l'analyzer aes cbc

Author: e-mandy

src/analyzers/aes_cbc_analyzer.py

@@ -99,7 +99,7 @@ def generer_cles_candidates(self, chemin_dictionnaire: str) -> list[bytes]:
         chemin_dictionnaire(str): le chemin du dictionnaire de mots de passes pour l'attaque par dictionnaire.
         
       Returns:
-        list[bytes]: liste des clés candidates.
+        list[bytes]: liste des clés candidates. 
     '''
 
     mots_de_passe_cible = self.filtrer_dictionnaire_par_indices(chemin_dictionnaire)

src/utils.py

@@ -3,7 +3,6 @@
 import sys
 import os
 
-
 def calculer_entropie(bytes) -> float:
    '''
       Calcul l'entropie (le désordre dans une suite de données) afin de déterminer le degré d'improbabilité d'une chaine de données.

tests/test_analyzers.py

@@ -0,0 +1,33 @@
+from unittest import TestCase, main
+import sys
+sys.path.append('.')
+sys.path.append('..')
+from src.analyzers.aes_cbc_analyzer import Aes_Cbc_Analyzer
+
+class AnalyzersTester(TestCase):
+
+    """
+        Cette classe est principalement destinée à recueillir toutes les fonctions de test des analyseurs d'algorithme
+        de chiffrement.
+    """
+    
+    def setUp(self):
+        self.chemin_fichier_chiffre = "data/mission1.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)
+
+    def test_aes_cbc_filtrage_dict(self):
+        self.assertIsInstance(self.analyser.filtrer_dictionnaire_par_indices(self.wordlist), list)
+
+    def test_generation_cles_candidate(self):
+        self.assertIsInstance(self.analyser.generer_cles_candidates(self.wordlist), list)
+
+    def test_exception_dechiffrer(self):
+        with self.assertRaises(FileNotFoundError):
+            self.analyser.dechiffrer("no_file_dohi.txt", self.analyser.generer_cles_candidates(self.wordlist))
+
+main()

tests/test_global.py

@@ -15,6 +15,20 @@ def add(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) 
+
+        # En fonction du type de vérification que vous souhaitez effectué par rapport aux test les méthodes assert devront variés.
+        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)
+
+        NB : Pour tester sa fonction chacun devra faire un import pour éviter la redondance.
+        Chaque fonction à tester devra se retrouver dans la class BetaTester avec un nom clair et propre à sa fonctionnalité précédé du mot "test"
+
+        command : pyhton test_global.py [-v (-- verbose)] (verbose pour un test avec plus de précision)
+
+    """
 
     def test_addition(self):
         self.assertEqual(add(5,5),10)
@@ -27,20 +41,4 @@ def test_calcul_entropie(self):
         self.assertGreater(calculer_entropie("aaaaaaaa"), 0)
 
 
-
-
-""" 
-    # 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) 
-
-    # En fonction du type de vérification que vous souhaitez effectué par rapport aux test les méthodes assert devront variés.
-    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)
-
-    NB : Pour tester sa fonction chacun devra faire un import pour éviter la redondance.
-    Chaque fonction à tester devra se retrouver dans la class BetaTester avec un nom clair et propre à sa fonctionnalité précédé du mot "test"
-
-    command : pyhton test_global.py [-v (-- verbose)] (verbose pour un test avec plus de précision)
-
-"""
 main()