Test: Amélioration de la couverture des tests unitaires (#28)

- Ajout de tests unitaires afin d'augmenter la couverture des tests
  unitaires sur le code
- Amélioration de la docstring des fonctions de test unitaire
- Ajout de la nouvelle dépendance 'pytest-mock' qui est nécessaire pour
  les tests unitaires du module main.py
- Ajout d'une fonction main dans main.py pour faciliter les tests
  unitaires
- Suppression d'une vérification de type dans parseur_log_apache.py qui
  ne pouvait jamais être atteinte grâce au regex

Author: AnthonyGuillauma

.github/workflows/tests.yaml

@@ -33,6 +33,7 @@ jobs:
           python -m pip install --upgrade pip
           pip install pytest
           pip install pytest-cov
+          pip install pytest-mock
 
       # Étape 4 : Lancer les tests unitaires
       - name: Lancer les tests unitaires

app/main.py

@@ -8,7 +8,10 @@
 from analyse.analyseur_log_apache import AnalyseurLogApache
 
 
-if __name__ == "__main__":
+def main():
+    """
+    Point d'entrée de l'application.
+    """
     colorama.init()
     print(colorama.Style.DIM + r"""
                                   .-. .-')                 .-')    .-') _     ('-.  _  .-')  ,---.
@@ -41,3 +44,7 @@
         print(f"Erreur dans l'analyse du log Apache !\n{ex}")
     except Exception as ex:
         print(f"Erreur interne !\n{ex}")
+
+
+if __name__ == "__main__":
+    main()

app/parse/parseur_log_apache.py

@@ -114,11 +114,7 @@ def parse_entree(self, entree):
 
         # Récupération des informations liées à la réponse
         code_statut = self.get_information_entree(resultat_analyse, "code_status")
-        if code_statut:
-            code_statut = int(code_statut)
-
-        if code_statut is None:
-            raise FormatLogApacheInvalideException("Le code de statut HTTP est obligatoire.")
+        code_statut = int(code_statut)
 
         taille_octets = self.get_information_entree(resultat_analyse, "taille_octets")
         if taille_octets:

tests/conftest.py

@@ -36,7 +36,11 @@
 
         '::1 - - [05/Mar/2025:16:59:43] "DELETE / HTTP/2.1" 200 20',
 
-        '192.168.1.1 - [12/Jan/2025:10:15:32 +0000] "GET /index.html HTTP/1.1" test 532'
+        '- - - [12/Jan/2025:10:15:32 +0000] "GET /index.html HTTP/1.1" 500 532',
+
+        '::1 - - - "GET /index.html HTTP/1.1" 500 532',
+
+        '::1 - - [12/Jan/2025:10:15:32 +0000] "GET /index.html HTTP/1.1" - 120'
 ]
 
 # ------------------
@@ -47,6 +51,7 @@
 def parseur_arguments_cli():
     """
     Fixture pour initialiser le parseur d'arguments CLI.
+
     Returns:
         ParseurArgumentsCLI: Une instance de la classe :class:`ParseurArgumentsCLI`.
     """
@@ -58,18 +63,22 @@ def log_apache(tmp_path):
     Fixture pour créer et récupérer un fichier de log Apache temporaire.
     Elle permet de générer un fichier de log Apache temporaire contenant
     soit des lignes valides, soit des lignes invalides selon le paramètre fourni.
+
     Args:
         tmp_path (Path): Chemin temporaire fourni par pytest.
+
     Returns:
         Callable[[bool], Path]: Une fonction qui crée et retourne le chemin 
         du fichier de log temporaire.
     """
     def _creer_log(valide):
         """
         Crée un fichier de log Apache temporaire.
+
         Args:
             valide (bool): Si ``True``, le fichier contient des lignes de log valides.
                 Sinon, il contient des lignes invalides.
+
         Returns:
             Path: Le chemin du fichier de log temporaire créé.
         """
@@ -87,12 +96,14 @@ def _creer_log(valide):
 def parseur_log_apache(log_apache, request):
     """
     Fixture pour initialiser un parseur de fichier de log Apache.
+
     Args:
         log_apache: La fixture pour initialiser un fichier temporaire.
         request: Paramètre de la fonction. Si il est égale à ``False``, cette fixture
             retourne un parseur de log Apache qui analyse un fichier avec un format
             invalide. Sinon, retourne un parseur de log Apache qui analyse un fichier
             avec un format valide.
+
     Returns:
         ParseurLogApache: Une instance de la classe :class:`ParseurLogApache`.
     """
@@ -106,17 +117,43 @@ def fichier_log_apache(parseur_log_apache):
     Fixture pour initialiser une représentation d'un fichier de log Apache.
     Cette représentation comprend par défaut les entrées parsées de la liste
     ``lignes_valides``.
+
+    Args:
+        parseur_arguments_cli (ParseurArgumentsCLI): Fixture pour l'instance 
+            de la classe :class:`ParseurLogApache`.
+
     Returns:
         FichierLogApache: Une instance de la classe :class:`FichierLogApache`.
     """
     return parseur_log_apache.parse_fichier()
 
+@pytest.fixture()
+def entree_log_apache(fichier_log_apache):
+    """
+    Fixture pour initialiser une représentation d'une entrée d'un fichier de log Apache.
+    Cette représentation comprend par défaut les informations de la première ligne de
+    ``lignes_valides``.
+
+    Args:
+        fichier_log_apache (FichierLogApache): Fixture pour l'instance 
+            de la classe :class:`FichierLogApache`.
+
+    Returns:
+        EntreeLogApache: Une instance de la classe :class:`EntreeLogApache`.
+    """
+    return fichier_log_apache.entrees[0]
+
 @pytest.fixture()
 def analyseur_log_apache(fichier_log_apache):
     """
     Fixture pour initialiser un analyseur statistique de fichier de log Apache.
     Le fichier qu'analyse cet analyseur comprend par défaut les entrées parsées de la liste
     ``lignes_valides``.
+
+    Args:
+        fichier_log_apache (FichierLogApache): Fixture pour l'instance 
+            de la classe :class:`FichierLogApache`.
+
     Returns:
         AnalyseurLogApache: Une instance de la classe :class:`AnalyseurLogApache`.
     """

tests/test_analyseur_log_apache.py

@@ -6,13 +6,14 @@
 from parse.fichier_log_apache import FichierLogApache
 from analyse.analyseur_log_apache import AnalyseurLogApache
 
+
 # Tests unitaires
 
 @pytest.mark.parametrize("fichier, nombre_par_top", [
     (False, 3),
     (FichierLogApache("test.log"), False)
 ])
-def test_analyseur_exception_type_invalide(fichier, nombre_par_top):
+def test_analyseur_log_exception_type_invalide(fichier, nombre_par_top):
     """
     Vérifie que la classe AnalyseurLogApache lève une :class:`TypeError` si les types des 
     paramètres du constructeur sont invalides.
@@ -21,20 +22,26 @@ def test_analyseur_exception_type_invalide(fichier, nombre_par_top):
         - Type incorrect pour le paramètre ``fichier``.
         - Type incorrect pour le paramètre ``nombre_par_top``.
 
+    Asserts:
+        - Une exception :class:`TypeError` est levée.
+
     Args:
         fichier (any): Représentation du fichier log.
         nombre_par_top (any): Nombre maximum d'éléments dans le top classement.
     """
     with pytest.raises(TypeError):
         analyseur = AnalyseurLogApache(fichier, nombre_par_top)
 
-def test_analyseur_exception_valeur_nombre_par_top_invalide():
+def test_analyseur_log_exception_valeur_nombre_par_top_invalide():
     """
-    Vérifie que la classe AnalyseurLogApache lève une :class:`ValueError` si le
+    Vérifie que la classe AnalyseurLogApache lève une exception si le
     paramètre ``nombre_par_top`` du constructeur est un entier négatif.
 
     Scénarios testés:
         - Nombre négatif pour ``nombre_par_top``.
+    
+    Asserts:
+        - Une exception :class:`ValueError` est levée.
     """
     with pytest.raises(ValueError):
         analyseur = AnalyseurLogApache(FichierLogApache("test.log"), -4)
@@ -49,12 +56,15 @@ def test_analyseur_exception_repartition_elements_type_invalide(analyseur_log_ap
                                                       nom_element, 
                                                       mode_top_classement):
     """
-    Vérifie que _get_repartition_elements lève une :class:`TypeError` si les types sont invalides.
+    Vérifie que _get_repartition_elements lève une exception si les types sont invalides.
 
     Scénarios testés:
-        - ``liste_elements`` n'est pas une ``list``.
-        - ``nom_element`` n'est pas un ``str``.
-        - ``mode_top_classement`` n'est pas un ``bool``.
+        - Type incorrect pour le paramètre ``liste_elements``.
+        - Type incorrect pour le paramètre ``nom_element``.
+        - Type incorrect pour le paramètre ``mode_top_classement``.
+
+    Asserts:
+        - Une exception :class:`TypeError` est levée.
 
     Args:
         analyseur_log_apache (AnalyseurLogApache): Fixture pour l'instance 
@@ -201,4 +211,62 @@ def test_analyseur_repartition_code_statut_htpp_valide(analyseur_log_apache):
     assert repartition[0]["taux"] == 80.0
     assert repartition[1]["code"] == 200
     assert repartition[1]["total"] == 1
-    assert repartition[1]["taux"] == 20.0
+    assert repartition[1]["taux"] == 20.0
+
+@pytest.mark.parametrize("nombre_entrees", [
+    (0), (3), (100)
+])
+def test_analyseur_get_total_entrees_valide(analyseur_log_apache,
+                                            fichier_log_apache, 
+                                            entree_log_apache, 
+                                            nombre_entrees):
+    """
+    Vérifie que ``get_total_entrees`` retourne le nombre correcte d'entrées dans le fichier.
+
+    Scénarios testés:
+        - Vérification avec des fichiers avec des nombre d'entrées différents.
+
+    Asserts:
+        - La méthode renvoie le nombre d'éléments dans la liste.
+        
+    Args:
+        analyseur_log_apache (AnalyseurLogApache): Fixture pour l'instance 
+            de la classe :class:`AnalyseurLogApache`.
+        fichier_log_apache (FichierLogApache): Fixture pour l'instance 
+            de la classe :class:`FichierLogApache`.
+        entree_log_apache (EntreeLogApache): Fixture pour l'instance 
+            de la classe :class:`EntreeLogApache`.
+        nombre_entrees (int): Le nombre total d'entrées dans le fichier.
+    """
+    fichier_log_apache.entrees = [entree_log_apache] * nombre_entrees
+    assert analyseur_log_apache.get_total_entrees() == nombre_entrees
+
+def test_analyseur_get_analyse_complete_valide(analyseur_log_apache):
+    """
+    Vérifie que ``get_analyse_complete`` retourne un rapport de l'analyse correct
+    qui se base sur le retour des autres méthodes.
+
+    Scénarios testés:
+        - Vérification du rapport de l'analyse.
+
+    Asserts:
+        - Les éléments du rapport se basent sur les mêmes valeurs que les autres méthodes.
+        
+    Args:
+        analyseur_log_apache (AnalyseurLogApache): Fixture pour l'instance 
+            de la classe :class:`AnalyseurLogApache`.
+        fichier_log_apache (FichierLogApache): Fixture pour l'instance 
+            de la classe :class:`FichierLogApache`.
+        entree_log_apache (EntreeLogApache): Fixture pour l'instance 
+            de la classe :class:`EntreeLogApache`.
+        nombre_entrees (int): Le nombre total d'entrées dans le fichier.
+    """
+    analyse = analyseur_log_apache.get_analyse_complete()
+    assert analyse["chemin"] == analyseur_log_apache.fichier.chemin
+    statistiques = analyse["statistiques"]
+    assert statistiques["total_entrees"] == analyseur_log_apache.get_total_entrees()
+    statistiques_requetes = statistiques["requetes"]
+    assert statistiques_requetes["top_urls"] == analyseur_log_apache.get_top_urls()
+    assert (statistiques_requetes["repartition_code_statut_http"] 
+            == analyseur_log_apache.get_total_par_code_statut_http())
+