Feat: Ajout de l'exportation des données (#30)

- Création du dossier export
- Création de la classe Exporteur dans le module exporteur.py
- Ajout de l'exception ExportationException
- Utilisation de l'exportation dans le module main.py
- Ajout des tests unitaires pour la classe Exporteur
- Ajout de la documentation pour la classe Exporteur

Author: AnthonyGuillauma

app/export/exporteur.py

@@ -0,0 +1,72 @@
+"""
+Module pour l'exportation des données.
+"""
+
+from os.path import abspath, dirname, isdir
+from json import dump
+
+
+class Exporteur:
+    """
+    Représente un exporteur de données pour exporter des données
+    vers un fichier de sortie.
+
+    Attributes:
+        _chemin_sortie (str): Le chemin du fichier vers lequel
+                les données seront exportées.
+    """
+
+    def __init__(self, chemin_sortie: str):
+        """
+        Initialise un exporteur de données.
+
+        Args:
+            chemin_sortie (str): Le chemin du fichier vers lequel
+                les données seront exportées.
+        
+        Raises:
+            TypeError: Le chemin de sortie n'est pas une chaîne de caractère.
+            ExportationException: Exportation impossible à cause de
+                l'emplacement invalide du fichier de sortie.
+        """
+        if not isinstance(chemin_sortie, str):
+            raise TypeError("Le chemin de sortie doit être une chaîne de caractère.")
+        chemin_sortie_absolue = abspath(chemin_sortie)
+        dossier_parent = dirname(chemin_sortie_absolue)
+        if not isdir(dossier_parent):
+            raise ExportationException(f"Impossible d'exporter vers le "
+                                       f"fichier {chemin_sortie}, son dossier parent "
+                                       f"{dossier_parent} n'existe pas.")
+        self._chemin_sortie = chemin_sortie
+
+    def export_vers_json(self, donnees: dict):
+        """
+        Export le dictionnaire fourni vers le :attr:`chemin de sortie`.
+
+        Args:
+            donnees (dict): Le dictionnaire qui contient les données.
+
+        Returns:
+            None
+
+        Raises:
+            TypeError: Le paramètre ``donnees`` n'est pas un dictionnaire.
+            ExportationException: Une erreur lors de l'écriture dans le fichier JSON.
+        """
+        if not isinstance(donnees, dict):
+            raise TypeError("Les données à exporter doivent être sous une forme "
+            "de dictionnaire.")
+        
+        try:
+            with open(self._chemin_sortie, 'w') as fichier:
+                dump(donnees, fichier, indent=4)
+        except Exception as ex:
+            raise ExportationException(str(ex)) from ex
+
+class ExportationException(Exception):
+    """
+    Représente une erreur lors de l'exportation de données.
+    """
+    
+    def __init__(self, *args):
+        super().__init__(*args)

app/main.py

@@ -6,6 +6,7 @@
 from cli.parseur_arguments_cli import ParseurArgumentsCLI, ArgumentCLIException
 from parse.parseur_log_apache import ParseurLogApache, FormatLogApacheInvalideException
 from analyse.analyseur_log_apache import AnalyseurLogApache
+from export.exporteur import Exporteur, ExportationException
 
 
 def main():
@@ -36,12 +37,16 @@ def main():
         analyseur_log = AnalyseurLogApache(fichier_log)
         analyse = analyseur_log.get_analyse_complete()
         # Exportation de l'analyse
+        exporteur = Exporteur(arguments_cli.sortie)
+        exporteur.export_vers_json(analyse)
     except ArgumentCLIException as ex:
         print(f"Erreur dans les arguments fournis !\n {ex}")
     except FileNotFoundError as ex:
         print(f"Erreur dans la recherche du log Apache !\n{ex}")
     except FormatLogApacheInvalideException as ex:
         print(f"Erreur dans l'analyse du log Apache !\n{ex}")
+    except ExportationException as ex:
+        print(f"Erreur dans l'exportation de l'analyse !\n{ex}")
     except Exception as ex:
         print(f"Erreur interne !\n{ex}")
 

docs/source/modules/export/exporteur.rst

@@ -0,0 +1,7 @@
+Exporteur
+==========
+
+.. automodule:: export.exporteur
+   :members:
+   :show-inheritance:
+   :undoc-members:

docs/source/modules/export/index_export.rst

@@ -0,0 +1,7 @@
+Export
+===========
+
+.. toctree::
+   :maxdepth: 4
+
+   exporteur.rst

docs/source/modules/index_modules.rst

@@ -9,4 +9,5 @@ Modules
    cli/index_cli.rst
    parse/index_parse.rst
    donnees/index_donnees.rst
-   analyse/index_analyse.rst
+   analyse/index_analyse.rst
+   export/index_export.rst

tests/conftest.py

@@ -4,9 +4,9 @@
 
 import pytest
 from cli.parseur_arguments_cli import ParseurArgumentsCLI
-from parse.fichier_log_apache import FichierLogApache
 from parse.parseur_log_apache import ParseurLogApache
 from analyse.analyseur_log_apache import AnalyseurLogApache
+from export.exporteur import Exporteur
 
 
 # -----------------
@@ -98,8 +98,8 @@ 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
+        log_apache (Path): La fixture pour initialiser un fichier temporaire.
+        request (object): 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.
@@ -157,4 +157,32 @@ def analyseur_log_apache(fichier_log_apache):
     Returns:
         AnalyseurLogApache: Une instance de la classe :class:`AnalyseurLogApache`.
     """
-    return AnalyseurLogApache(fichier_log_apache)
+    return AnalyseurLogApache(fichier_log_apache)
+
+@pytest.fixture
+def fichier_json(tmp_path):
+    """
+    Fixture pour retourner un chemin de fichier JSON temporaire.
+
+    Args:
+        tmp_path (Path): Chemin temporaire fourni par pytest.
+
+    Returns:
+        Path: Un chemin de fichier JSON temporaire.
+    """
+    fichier_temp = tmp_path / "sortie.json"
+    return fichier_temp
+
+@pytest.fixture
+def exporteur(fichier_json):
+    """
+    Fixture pour initialiser un exportateur de données.
+
+    Args:
+        fichier_json (Path): Fixture pour initialiser 
+            un chemin de fichier json temporaire.
+
+    Returns:
+        Exporteur: Une instance de la classe :class:`Exportateur`.
+    """
+    return Exporteur(str(fichier_json))

tests/test_exporteur.py

@@ -0,0 +1,112 @@
+"""
+Module des tests unitaires pour l'exporteur de données.
+"""
+
+import pytest
+from json import load
+from export.exporteur import Exporteur, ExportationException
+
+@pytest.mark.parametrize("chemin_sortie", [
+    (0), (None), ([])
+])
+def test_exporteur_type_chemin_invalide(chemin_sortie):
+    """
+    Vérifie que la classe renvoie une erreur lorsque un argument de type invalide
+    est passé dans le constructeur.
+
+    Scénarios testés:
+        - Type incorrect pour le paramètre ``chemin_sortie``.
+
+    Asserts:
+        - Une exception :class:`TypeError` est levée.
+
+    Args:
+        chemin_sortie (any): Le chemin de sortie utilisé dans le constructeur.
+    """
+    with pytest.raises(TypeError):
+        exporteur = Exporteur(chemin_sortie)
+
+def test_exporteur_emplacement_inexistant():
+    """
+    Vérifie que la classe renvoie une erreur lorsque un chemin de fichier invalide
+    est passé dans le constructeur.
+
+    Scénarios testés:
+        - Chemin invalide pour le paramètre ``chemin_sortie``.
+
+    Asserts:
+        - Une exception :class:`ExportationException` est levée.
+    """
+    with pytest.raises(ExportationException):
+        exporteur = Exporteur("dossier/inexistant/sortie.json")
+
+@pytest.mark.parametrize("donnees", [
+    (0), (None), ([])
+])
+def test_exportateur_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``.
+
+    Scénarios testés:
+        - Type incorrect pour le paramètre ``données``.
+
+    Asserts:
+        - Une exception :class:`TypeError` est levée.
+
+    Args:
+        exporteur (Exporteur) : Fixture pour l'instance de la classe :class:`Exporteur`.
+        donnees (any): Les données à exporter.
+    """
+    with pytest.raises(TypeError):
+        exporteur.export_vers_json("type invalide")
+
+@pytest.mark.parametrize("exception", [
+    (PermissionError("Pas les droits")),
+    (FileNotFoundError("Fichier non trouvé.")),
+    (Exception("Toutes exceptions"))
+])
+def test_exportateur_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.
+
+    Scénarios testés:
+        - Une exception :class:`PermissionError` survient.
+        - Une exception :class:`FileNotFoundError` survient.
+        - Une exception :class:`Exception` survient.
+
+    Asserts:
+        - Une exception :class:`ExportationException` est levée.
+
+    Args:
+        exporteur (Exporteur) : Fixture pour l'instance de la classe :class:`Exporteur`.
+        mocker (any): Une fixture pour simuler des exceptions.
+        donnees (any): Les données à exporter.
+    """
+    mocker.patch("builtins.open", side_effect=exception)
+    with pytest.raises(ExportationException):
+        exporteur.export_vers_json({})
+
+def test_exportateur_exportation_json_valide(exporteur, fichier_json):
+    """
+    Vérifie que la méthode ``export_vers_json`` exporte correctement les données
+    vers une fichier.
+
+    Scénarios testés:
+        - Exportation d'un dictionnaire lambda.
+
+    Asserts:
+        - Le fichier est bien crée.
+        - Les données dans le fichier sont conformes à celles fournies.
+
+    Args:
+        exporteur (Exporteur) : Fixture pour l'instance de la classe :class:`Exporteur`.
+        fichier_json (Path): Le chemin du fichier.
+    """
+    donnees = {"cle": {"valeur": [1, 2, 3]}}
+    exporteur.export_vers_json(donnees)
+    assert fichier_json.exists()
+    with open(fichier_json, "r") as exportation:
+        contenu_exportation = load(exportation)
+    assert contenu_exportation == donnees

tests/test_main.py

@@ -7,11 +7,13 @@
 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)
 ])
 def test_main_gestion_exception(mocker, exception):
@@ -50,6 +52,8 @@ def test_main_succes(mocker):
 
     mock_analyseur_log = mocker.patch("main.AnalyseurLogApache")
     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: