Test: Mise à jour des tests unitaires après la mise en place de PEP8

- Mise à jour des tests unitaires suite à la modification du code pour
  être conforme avec PEP8

Author: AnthonyGuillauma

tests/conftest.py

@@ -113,8 +113,8 @@ def parseur_log_apache(log_apache, request):
         ParseurLogApache: Une instance de la classe :class:`ParseurLogApache`.
     """
     if hasattr(request, "param") and request.param == False:
-        return ParseurLogApache(log_apache(False))
-    return ParseurLogApache(log_apache(True))
+        return ParseurLogApache(str(log_apache(False)))
+    return ParseurLogApache(str(log_apache(True)))
 
 @pytest.fixture()
 def fichier_log_apache(parseur_log_apache):

tests/test_afficheur_cli.py

@@ -169,6 +169,23 @@ def test_afficheur_cli_lance_animation_chargement(mocker, afficheur_cli):
     assert afficheur_cli._thread_chargement is not None
     assert afficheur_cli._thread_chargement.is_alive()
 
+def test_afficheur_cli_exception_stop_animation_chargment_type_invalide(afficheur_cli):
+    """
+    Vérifie que la méthode stop_animation_chargement renvoie une erreur lorsque le type
+    de son paramètre est invalide.
+
+    Scénarios testés:
+        - Paramètre ``erreur`` avec un mauvais type.
+
+    Asserts:
+        - Une exception :class:`TypeError` est levée.
+
+    Args:
+        afficheur_cli (AfficheurCLI): Fixture pour l'instance de la classe ``AfficheurCLI``.
+    """
+    with pytest.raises(TypeError):
+        afficheur_cli.stop_animation_chargement("False")
+
 def test_afficheur_cli_stop_animation_chargement_terminee(afficheur_cli):
     """
     Vérifie que la méthode stop_animation_chargement arrête correctement l'animation en

tests/test_exporteur.py

@@ -40,10 +40,27 @@ def test_exporteur_emplacement_inexistant():
     with pytest.raises(ExportationException):
         exporteur = Exporteur("dossier/inexistant/sortie.json")
 
+def test_exporteur_verification_exception_exportation_possible_type_invalide(exporteur):
+    """
+    Vérifie que la méthode verification_exportation_possible renvoie une erreur lorsque le type
+    de son paramètre est invalide.
+
+    Scénarios testés:
+        - Paramètre ``chemin_sortie`` avec un mauvais type.
+
+    Asserts:
+        - Une exception :class:`TypeError` est levée.
+
+    Args:
+        exporteur (Exporteur) : Fixture pour l'instance de la classe :class:`Exporteur`.
+    """
+    with pytest.raises(TypeError):
+        exporteur.verification_exportation_possible(False)
+
 @pytest.mark.parametrize("donnees", [
     (0), (None), ([])
 ])
-def test_exportateur_export_json_type_donnees_invalide(exporteur, donnees):
+def test_exporteur_export_json_type_donnees_invalide(exporteur, donnees):
     """
     Vérifie que la classe renvoie une erreur lorsque un argument de type invalide
     est passé dans la méthode ``export_vers_json``.
@@ -66,7 +83,7 @@ def test_exportateur_export_json_type_donnees_invalide(exporteur, donnees):
     (FileNotFoundError("Fichier non trouvé.")),
     (Exception("Toutes exceptions"))
 ])
-def test_exportateur_export_json_exception_exportation(exporteur, mocker, exception):
+def test_exporteur_export_json_exception_exportation(exporteur, mocker, exception):
     """
     Vérifie que la classe renvoie l'exception :class:`ExportationException` lorsque
     une erreur apparait durant l'exportation des données.
@@ -88,7 +105,7 @@ def test_exportateur_export_json_exception_exportation(exporteur, mocker, except
     with pytest.raises(ExportationException):
         exporteur.export_vers_json({})
 
-def test_exportateur_exportation_json_valide(exporteur, fichier_json):
+def test_exporteur_exportation_json_valide(exporteur, fichier_json):
     """
     Vérifie que la méthode ``export_vers_json`` exporte correctement les données
     vers une fichier.

tests/test_fichier_entree_log_apache.py

@@ -0,0 +1,86 @@
+"""
+Module des tests unitaires pour la classe de représentation d'un fichier de log
+ou celle d'une entrée d'un log.
+"""
+
+import pytest
+from datetime import datetime
+from parse.fichier_log_apache import FichierLogApache
+from parse.entree_log_apache import EntreeLogApache
+from donnees.client_informations import ClientInformations
+from donnees.requete_informations import RequeteInformations
+from donnees.reponse_informations import ReponseInformations
+
+
+@pytest.mark.parametrize("chemin, entrees", [
+    (False, []),
+    ("Chemin", False)
+])
+def test_fichier_log_exception_type_invalide(chemin, entrees):
+    """
+    Vérifie que l'initialisation d'un FichierLogApache renvoie une erreur lorsque le type
+    de son paramètre est invalide.
+
+    Scénarios testés:
+        - Paramètre ``chemin`` avec un mauvais type.
+        - Paramètre ``entrees`` avec un mauvais type.
+
+    Asserts:
+        - Une exception :class:`TypeError` est levée.
+
+    Args:
+        chemin (any): Le chemin du fichier.
+        entrees (any): Les entrées du fichier.
+    """
+    with pytest.raises(TypeError):
+        fichier = FichierLogApache(chemin, entrees)
+
+def test_fichier_log_exception_ajoute_entree_type_invalide(fichier_log_apache):
+    """
+    Vérifie que la méthode ajoute_entree retourne une erreur lorsque son paramètre
+    n'est pas du type attendu.
+
+    Scénarios testés:
+        - Paramètre ``entree`` avec un mauvais type.
+
+    Asserts:
+        - Une exception :class:`TypeError` est levée.
+
+    Args:
+        fichier_log_apache (FichierLogApache): Fixture pour l'instance 
+            de la classe :class:`FichierLogApache`.
+    """
+    with pytest.raises(TypeError):
+        fichier_log_apache.ajoute_entree(False)
+
+@pytest.mark.parametrize("client, requete, reponse", [
+    (False,
+     RequeteInformations(datetime(1, 1, 1), "GET", "/", "HTTP/1.1", "/"),
+     ReponseInformations(0, 0)),
+    (ClientInformations("1.1.1.1", "RFC", "test", "google"),
+     False,
+     ReponseInformations(0, 0)),
+    (ClientInformations("1.1.1.1", "RFC", "test", "google"),
+     RequeteInformations(datetime(1, 1, 1), "GET", "/", "HTTP/1.1", "/"),
+     False)
+])
+def test_entree_log_exception_type_invalide(client, requete, reponse):
+    """
+    Vérifie que l'initialisation d'un EntreeLogApache renvoie une erreur lorsque le type
+    de son paramètre est invalide.
+
+    Scénarios testés:
+        - Paramètre ``client`` avec un mauvais type.
+        - Paramètre ``requete`` avec un mauvais type.
+        - Paramètre ``reponse`` avec un mauvais type.
+
+    Asserts:
+        - Une exception :class:`TypeError` est levée.
+
+    Args:
+        client (any): Les informations du client sur cette entrée.
+        requete (any): Les informations de la requête sur cette entrée.
+        reponse (any): Les informations de la réponse sur cette entrée.
+    """
+    with pytest.raises(TypeError):
+        entree = EntreeLogApache(client, requete, reponse)

tests/test_main.py

@@ -3,22 +3,25 @@
 """
 
 import pytest
-import sys
 from main import main
 from cli.parseur_arguments_cli import ArgumentCLIException
 from parse.parseur_log_apache import FormatLogApacheInvalideException
 from export.exporteur import ExportationException
 
-@pytest.mark.parametrize("exception", [
-    (ArgumentCLIException),
-    (FileNotFoundError),
-    (FormatLogApacheInvalideException),
-    (ExportationException),
-    (Exception)
-])
+
+@pytest.mark.parametrize(
+    "exception",
+    [
+        (ArgumentCLIException),
+        (FormatLogApacheInvalideException),
+        (ExportationException),
+        (TypeError),
+        (ValueError),
+    ],
+)
 def test_main_gestion_exception(mocker, exception):
     """
-    Vérifie que les exceptions sont interceptées dans fichier principal.
+    Vérifie que les exceptions attendues sont interceptées dans fichier principal.
 
     Scénarios testés:
         - Vérification que les exceptions n'arrête pas le programme.
@@ -45,18 +48,22 @@ def test_main_succes(mocker):
     """
     # Mock des classes pour simuler un fonctionnement correct
     mock_parseur_cli = mocker.patch("main.ParseurArgumentsCLI")
-    mock_parseur_cli.return_value.parse_args.return_value = mocker.MagicMock(chemin_log="test.log")
-    
+    mock_parseur_cli.return_value.parse_args.return_value = mocker.MagicMock(
+        chemin_log="test.log"
+    )
+
     mock_parseur_log = mocker.patch("main.ParseurLogApache")
     mock_parseur_log.return_value.parse_fichier.return_value = mocker.MagicMock()
-    
+
     mock_analyseur_log = mocker.patch("main.AnalyseurLogApache")
-    mock_analyseur_log.return_value.get_analyse_complete.return_value = {"chemin": "test.log"}
+    mock_analyseur_log.return_value.get_analyse_complete.return_value = {
+        "chemin": "test.log"
+    }
 
     mocker.patch("main.Exporteur")
-    
+
     # Vérifie qu'aucune exception n'est levée
     try:
         main()
     except Exception:
-        pytest.fail("Aucune exception ne doit être levée ici")
+        pytest.fail("Aucune exception ne doit être levée ici")

tests/test_parseur_arguments_cli.py

@@ -36,6 +36,31 @@
 
 # Tests unitaires
 
+@pytest.mark.parametrize("args, namespace", [
+    (False, None),
+    (None, False)
+])
+def test_parseur_cli_exception_parse_args_type_invalide(parseur_arguments_cli, args, namespace):
+    """
+    Vérifie que la méthode parse_args renvoie une erreur lorsque le type
+    d'un de ses paramètres est invalide.
+
+    Scénarios testés:
+        - Paramètre ``args`` avec un mauvais type.
+        - Paramètre ``namespace`` avec un mauvais type.
+
+    Asserts:
+        - Une exception :class:`TypeError` est levée.
+
+    Args:
+        parseur_arguments_cli (ParseurArgumentsCLI): Fixture pour l'instance 
+            de la classe :class:`ParseurArgumentsCLI`.
+        args (Optional[list]): Une liste avec des arguments.
+        namespace (Optional[Namespace]): L'espace de nom où stocker les arguments.
+    """
+    with pytest.raises(TypeError):
+        parseur_arguments_cli.parse_args(args, namespace)
+
 @pytest.mark.parametrize("arguments", arguments_invalides)
 def test_parseur_cli_exception_argument_inconnu(parseur_arguments_cli, arguments):
     """