diff --git a/.github/workflows/documentation.yaml b/.github/workflows/documentation.yaml index d47ea1c..abfeb05 100644 --- a/.github/workflows/documentation.yaml +++ b/.github/workflows/documentation.yaml @@ -33,6 +33,8 @@ jobs: pip install sphinx pip install sphinx_rtd_theme --break-system-packages pip install colorama + pip install altair + pip install pandas # Étape 4 : Générer la documentation - name: Construction de la documentation (avec Sphinx) diff --git a/.github/workflows/qualite.yaml b/.github/workflows/qualite.yaml index dbeec86..b7ef122 100644 --- a/.github/workflows/qualite.yaml +++ b/.github/workflows/qualite.yaml @@ -27,6 +27,8 @@ jobs: python -m pip install --upgrade pip pip install pylint pip install colorama + pip install altair + pip install pandas # Étape 4 : Lancement de l'analyse - name: Analyse avec Pylint (note >= 9.0 requise) diff --git a/.github/workflows/tests.yaml b/.github/workflows/tests.yaml index ead0807..d1c3aea 100644 --- a/.github/workflows/tests.yaml +++ b/.github/workflows/tests.yaml @@ -33,6 +33,8 @@ jobs: run: | python -m pip install --upgrade pip pip install colorama + pip install altair + pip install pandas pip install pytest pip install pytest-cov pip install pytest-mock diff --git a/app/analyse/analyseur_log_apache.py b/app/analyse/analyseur_log_apache.py index aebe41f..7b559a4 100644 --- a/app/analyse/analyseur_log_apache.py +++ b/app/analyse/analyseur_log_apache.py @@ -177,7 +177,7 @@ def get_top_urls(self) -> list: def get_total_par_code_statut_http(self) -> list: """ - Retourne la répartition des réponses par code de statut htpp retourné. + Retourne la répartition des réponses par code de statut http retourné. Les entrées prisent en compte sont uniquement celles qui ont passées le filtre. Returns: @@ -192,3 +192,18 @@ def get_total_par_code_statut_http(self) -> list: [entree.reponse.code_statut_http for entree in self._get_entrees_passent_filtre()], "code" ) + + def get_total_par_code_statut_http_camembert(self) -> list: + """ + Retourne la répartition des réponses par code de statut http retourné sous + un format utilisable par un camembert. + Les entrées prisent en compte sont uniquement celles qui ont passées le filtre. + + Returns: + list: Une liste de liste de deux éléments où l'index 0 est le code et l'index 1 + son total d'apparition. + """ + return [ + [stat["code"], stat["total"]] + for stat in self.get_total_par_code_statut_http() + ] diff --git a/app/cli/parseur_arguments_cli.py b/app/cli/parseur_arguments_cli.py index 74772fe..49125a2 100644 --- a/app/cli/parseur_arguments_cli.py +++ b/app/cli/parseur_arguments_cli.py @@ -40,9 +40,9 @@ def __set_arguments(self) -> None: "-s", "--sortie", type=str, - default="./analyse-log-apache.json", - help="Fichier JSON où sera écrit l'analyse. Par défaut, un fichier avec le " - "nom 'analyse-log-apache.json' dans le repertoire courant sera crée.", + default="./", + help="Dossier où sera écrit l'analyse du fichier de log Apache. Par défaut," + "sa valeur est le répertoire d'exécution du script.", ) self.add_argument( "-i", @@ -56,6 +56,11 @@ def __set_arguments(self) -> None: type=int, help="Le code de statut http que doivent avoir les entrées à analyser." ) + self.add_argument( + "--camembert", + action="store_true", + help="Active la génération d'histogrammes pour les statistiques compatibles." + ) def parse_args(self, args: Optional[list] = None, @@ -106,11 +111,6 @@ def parse_args(self, "chiffres ou les caractères spéciaux suivants: _, \\, -, /." ) - if not arguments_parses.sortie.endswith(".json"): - raise ArgumentCLIException( - "Le fichier de sortie doit obligatoirement être un fichier au format json." - ) - return arguments_parses diff --git a/app/export/exporteur.py b/app/export/exporteur.py index bbcc3c7..650c565 100644 --- a/app/export/exporteur.py +++ b/app/export/exporteur.py @@ -2,8 +2,10 @@ Module pour l'exportation des données. """ -from os.path import abspath, dirname, isdir +from os.path import abspath, isdir, join from json import dump +from altair import Chart +from pandas import DataFrame class Exporteur: @@ -12,88 +14,131 @@ class Exporteur: vers un fichier de sortie. Attributes: - _chemin_sortie (str): Le chemin du fichier vers lequel - les données seront exportées. + _chemin_sortie (str): Le chemin du dossier vers lequel les données + vont être 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. - ExportationDossierParentException: Exportation impossible à cause de - l'inexistance du dossier parent du fichier d'exportation. - """ - # Vérification du type du paramètre + # Vérification du paramètre if not isinstance(chemin_sortie, str): - raise TypeError("Le chemin de sortie doit être une chaîne de caractère.") - # Vérification du chemin d'exportation - self.verification_exportation_possible(chemin_sortie) - # Ajout du chemin d'exportation + raise TypeError("Le chemin de sortie doit être une chaîne de caractères.") + # Vérification du chemin + chemin_sortie_absolue = abspath(chemin_sortie) + if not isdir(chemin_sortie_absolue): + raise ExportationDossierIntrouvableException(f"Impossible d'exporter vers le " + f"dossier {chemin_sortie} ({chemin_sortie_absolue}), " + "le dossier n'existe pas.") + # Ajout du chemin self._chemin_sortie = chemin_sortie - def verification_exportation_possible(self, chemin_sortie: str) -> None: + def export_vers_json(self, donnees: dict, nom_fichier: str) -> None: """ - Vérifie qu'une exportation est possible vers le chemin du fichier indiqué. Renvoie une - exception expliquant le problème si elle n'est pas possible. + Export le dictionnaire fourni vers le ``chemin de sortie``. Args: - chemin_sortie (str): Le chemin du fichier d'exportation. + donnees (dict): Le dictionnaire qui contient les données. + nom_fichier (str): Le nom du fichier JSON. Returns: None Raises: - ExportationDossierParentException: Le dossier parent du fichier n'existe pas. + TypeError: Le paramètre ``donnees`` n'est pas un dictionnaire. + ExportationJsonException: Une erreur lors de l'écriture dans le fichier JSON. """ - # Vérification du type du paramètre - if not isinstance(chemin_sortie, str): - raise TypeError("Le chemin de sortie doit être une chaîne de caractères.") - # Vérification du chemin - chemin_sortie_absolue = abspath(chemin_sortie) - dossier_parent = dirname(chemin_sortie_absolue) - if not isdir(dossier_parent): - raise ExportationDossierParentException(f"Impossible d'exporter vers le " - f"fichier {chemin_sortie}, son dossier parent " - f"{dossier_parent} n'existe pas.") + # Vérification du type des paramètres + if not isinstance(donnees, dict): + raise TypeError("Les statistiques à exporter doivent être sous une forme " + "de dictionnaire.") + if not isinstance(nom_fichier, str): + raise TypeError("Le nom du fichier doit être une chaîne de caractère.") + # Vérification du nom du fichier + if not nom_fichier.endswith(".json"): + raise ValueError("Le fichier JSON doit terminé par l'extention '.json'.") + # Exportation + chemin_fichier = join(self._chemin_sortie, nom_fichier) + try: + with open(chemin_fichier, 'w', encoding="utf-8") as fichier: + dump(donnees, fichier, indent=4) + except Exception as ex: + raise ExportationJsonException(str(ex)) from ex - def export_vers_json(self, donnees: dict) -> None: + def export_vers_html_camembert(self, + donnees: list, + nom_fichier: str) -> None: """ - Export le dictionnaire fourni vers le :attr:`chemin de sortie`. + Export la liste fournie vers un camembert HTML vers le ``chemin de sortie``. Args: - donnees (dict): Le dictionnaire qui contient les données. + donnees (list): Les données du camembert. La liste doit contenir + des listes de deux éléments où le premier reprèsente le nom de cette + partie du camembert et le deuxième sa valeur. + nom_fichier (str): Le nom du fichier HTML. Returns: None Raises: - TypeError: Le paramètre ``donnees`` n'est pas un dictionnaire. - ExportationException: Une erreur lors de l'écriture dans le fichier JSON. + TypeError: Les paramètres ne sont pas du type attendu ou la liste ``donnees`` + contient un élément qui n'est pas une liste. + ValueError: Le paramètre ``nom_fichier`` ne termine pas par .html ou le paramètre + ``donnees`` ne contient pas des listes de longueur 2. + ExportationCamembertHtmlException: Erreur lors de l'exportation du camembert. """ - # Vérification du type du paramètre - if not isinstance(donnees, dict): - raise TypeError("Les données à exporter doivent être sous une forme " - "de dictionnaire.") + # Vérification du type des paramètres + if not isinstance(donnees, list): + raise TypeError("Les données de l'histogramme à exporter doit être sous une forme " + "de liste.") + if not isinstance(nom_fichier, str): + raise TypeError("Le nom du fichier doit être une chaîne de caractère.") + # Vérification du nom du fichier + if not nom_fichier.endswith(".html"): + raise ValueError("Le fichier HTML doit terminé par l'extention '.html'.") + # Récupération des axes du graphique + axe_x = [] + axe_y = [] + for donnee in donnees: + if not isinstance(donnee, list): + raise ValueError("La liste des données de l'histogramme à exporter ne doit " + "contenir que des listes.") + if not len(donnee) == 2: + raise ValueError("La liste des données de l'histogramme à exporter ne doit " + "contenir que des listes de deux éléments (x, y).") + axe_x.append(donnee[0]) + axe_y.append(donnee[1]) + axes = DataFrame({"x": axe_x, "y": axe_y}) # Exportation try: - with open(self._chemin_sortie, 'w', encoding="utf-8") as fichier: - dump(donnees, fichier, indent=4) + chemin_fichier = join(self._chemin_sortie, nom_fichier) + camembert = Chart(axes).mark_arc().encode( + theta='y:Q', + color='x:N', + tooltip=['x:N', 'y:Q'] + ) + camembert.save(chemin_fichier) except Exception as ex: - raise ExportationException(str(ex)) from ex + raise ExportationCamembertHtmlException("Erreur lors de l'exportation " + f"du camembert {nom_fichier}.") from ex + class ExportationException(Exception): """ Représente une erreur lors de l'exportation de données. """ -class ExportationDossierParentException(ExportationException): +class ExportationJsonException(ExportationException): + """ + Représente une erreur lors de l'exportation de données vers un format JSON. + """ + +class ExportationCamembertHtmlException(ExportationException): + """ + Représente une erreur lors de l'exportation de données vers un histogramme + au format HTML. + """ + +class ExportationDossierIntrouvableException(ExportationException): """ Représente une erreur lorsque une exportation est impossible - lorsque le dossier parent du fichier d'exportation n'existe pas. + lorsque le dossier de l'exportation n'existe pas. """ diff --git a/app/main.py b/app/main.py index c201827..9114f28 100644 --- a/app/main.py +++ b/app/main.py @@ -8,7 +8,6 @@ from analyse.analyseur_log_apache import AnalyseurLogApache from export.exporteur import Exporteur, ExportationException - def main() -> None: """ Point d'entrée de l'application. @@ -32,9 +31,15 @@ def main() -> None: # Analyse statistique du fichier log analyseur_log = AnalyseurLogApache(fichier_log, filtre_log) analyse = analyseur_log.get_analyse_complete() - # Exportation de l'analyse + # Exportation JSON exporteur = Exporteur(arguments_cli.sortie) - exporteur.export_vers_json(analyse) + exporteur.export_vers_json(analyse, "analyse-log-apache.json") + # Exportation Camembert + if arguments_cli.camembert: + exporteur.export_vers_html_camembert( + analyseur_log.get_total_par_code_statut_http_camembert(), + "camembert-code_statut_http.html" + ) # Termine l'animation de chargement afficheur_cli.stop_animation_chargement() except ArgumentCLIException as ex: diff --git a/tests/conftest.py b/tests/conftest.py index 29241f4..44d8a5d 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -193,7 +193,7 @@ def fichier_json(tmp_path): return fichier_temp @pytest.fixture -def exporteur(fichier_json): +def exporteur(tmp_path): """ Fixture pour initialiser un exportateur de données. @@ -204,4 +204,4 @@ def exporteur(fichier_json): Returns: Exporteur: Une instance de la classe :class:`Exportateur`. """ - return Exporteur(str(fichier_json)) \ No newline at end of file + return Exporteur(str(tmp_path)) \ No newline at end of file diff --git a/tests/test_analyseur_log_apache.py b/tests/test_analyseur_log_apache.py index 89c746f..f8e14f3 100644 --- a/tests/test_analyseur_log_apache.py +++ b/tests/test_analyseur_log_apache.py @@ -218,6 +218,29 @@ def test_analyseur_repartition_code_statut_http_valide(analyseur_log_apache): assert repartition[1]["total"] == 1 assert repartition[1]["taux"] == 20.0 +def test_analyseur_repartition_code_statut_http_camembert_valide(analyseur_log_apache): + """ + Vérifie que ``get_total_par_code_statut_http_camembert`` retourne la répartition + correcte des codes HTTP. + + Scénarios testés: + - Vérification du tri et des indexs des listes dans la liste. + + Asserts: + - La liste est triée dans l'ordre attendu. + - Le nombre d'éléments dans le résultat correspond à celui attendu. + + Args: + analyseur_log_apache (AnalyseurLogApache): Fixture pour l'instance + de la classe ParseurLogApache. + """ + repartition = analyseur_log_apache.get_total_par_code_statut_http_camembert() + assert len(repartition) == 2 + assert repartition[0][0] == 500 + assert repartition[0][1] == 4 + assert repartition[1][0] == 200 + assert repartition[1][1] == 1 + @pytest.mark.parametrize("nombre_entrees", [ (0), (3), (100) ]) diff --git a/tests/test_exporteur.py b/tests/test_exporteur.py index d5b6819..3e4a180 100644 --- a/tests/test_exporteur.py +++ b/tests/test_exporteur.py @@ -4,7 +4,10 @@ import pytest from json import load -from export.exporteur import Exporteur, ExportationException +from export.exporteur import (Exporteur, + ExportationJsonException, + ExportationCamembertHtmlException, + ExportationDossierIntrouvableException) @pytest.mark.parametrize("chemin_sortie", [ (0), (None), ([]) @@ -28,39 +31,22 @@ def test_exporteur_type_chemin_invalide(chemin_sortie): def test_exporteur_emplacement_inexistant(): """ - Vérifie que la classe renvoie une erreur lorsque un chemin de fichier invalide + Vérifie que la classe renvoie une erreur lorsque un chemin de dossier 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. + - Une exception :class:`ExportationDossierIntrouvableException` est levée. """ - with pytest.raises(ExportationException): - exporteur = Exporteur("dossier/inexistant/sortie.json") + with pytest.raises(ExportationDossierIntrouvableException): + exporteur = Exporteur("dossier/inexistant/") -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), ([]) +@pytest.mark.parametrize("donnees, nom_fichier", [ + (False, "fichier.json"), ({}, False) ]) -def test_exporteur_export_json_type_donnees_invalide(exporteur, donnees): +def test_exporteur_export_json_type_donnees_invalide(exporteur, donnees, nom_fichier): """ Vérifie que la classe renvoie une erreur lorsque un argument de type invalide est passé dans la méthode ``export_vers_json``. @@ -76,7 +62,15 @@ def test_exporteur_export_json_type_donnees_invalide(exporteur, donnees): donnees (any): Les données à exporter. """ with pytest.raises(TypeError): - exporteur.export_vers_json("type invalide") + exporteur.export_vers_json(donnees, nom_fichier) + +@pytest.mark.parametrize("nom_fichier", [ + ("fichier.rst"), ("sorite.html") +]) +def test_exporteur_exeption_export_vers_json_fichier_invalide(exporteur, + nom_fichier): + with pytest.raises(ValueError): + exporteur.export_vers_json({}, nom_fichier) @pytest.mark.parametrize("exception", [ (PermissionError("Pas les droits")), @@ -85,7 +79,7 @@ def test_exporteur_export_json_type_donnees_invalide(exporteur, donnees): ]) def test_exporteur_export_json_exception_exportation(exporteur, mocker, exception): """ - Vérifie que la classe renvoie l'exception :class:`ExportationException` lorsque + Vérifie que la classe renvoie l'exception :class:`ExportationJsonException` lorsque une erreur apparait durant l'exportation des données. Scénarios testés: @@ -94,16 +88,16 @@ def test_exporteur_export_json_exception_exportation(exporteur, mocker, exceptio - Une exception :class:`Exception` survient. Asserts: - - Une exception :class:`ExportationException` est levée. + - Une exception :class:`ExportationJsonException` 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. + exception (any): L'exception levée dans la méthode. """ mocker.patch("builtins.open", side_effect=exception) - with pytest.raises(ExportationException): - exporteur.export_vers_json({}) + with pytest.raises(ExportationJsonException): + exporteur.export_vers_json({}, "fichier.json") def test_exporteur_exportation_json_valide(exporteur, fichier_json): """ @@ -122,8 +116,155 @@ def test_exporteur_exportation_json_valide(exporteur, fichier_json): fichier_json (Path): Le chemin du fichier. """ donnees = {"cle": {"valeur": [1, 2, 3]}} - exporteur.export_vers_json(donnees) + exporteur.export_vers_json(donnees, "sortie.json") assert fichier_json.exists() with open(fichier_json, "r") as exportation: contenu_exportation = load(exportation) - assert contenu_exportation == donnees \ No newline at end of file + assert contenu_exportation == donnees + +@pytest.mark.parametrize("donnees, nom_fichier", [ + (False, "fichier.html"), + ([], False) +]) +def test_exporteur_exception_export_vers_html_camembert_type_invalide(exporteur, + donnees, + nom_fichier): + """ + Vérifie qu'une exception est levée lorsque les paramètres ont des types incorrects. + + Scénarios testés: + - Type incorrect pour le paramètre ``donnees``. + - Type incorrect pour le paramètre ``nom_fichier``. + + 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 à mettre sous forme de camembert. + nom_fichier (any): Le nom du fichier HTML qui contient le camembert. + """ + with pytest.raises(TypeError): + exporteur.export_vers_html_camembert(donnees, nom_fichier) + +@pytest.mark.parametrize("nom_fichier", [ + ("fichier.rst"), ("sorite.json") +]) +def test_exporteur_exception_export_vers_html_camembert_fichier_invalide(exporteur, + nom_fichier): + """ + Vérifie qu'une exception est levée lorsque le nom du fichier n'est pas un + fichier HTML. + + Scénarios testés: + - Passage d'un nom de fichier qui ne termine pas par '.html'. + + Asserts: + - Une exception :class:`ValueError` est levée. + + Args: + exporteur (Exporteur) : Fixture pour l'instance de la classe :class:`Exporteur`. + nom_fichier (any): Le nom du fichier HTML qui contient le camembert. + """ + with pytest.raises(ValueError): + exporteur.export_vers_html_camembert([], nom_fichier) + +@pytest.mark.parametrize("donnees", [ + (["test"]), ([False]) +]) +def test_exporteur_exception_export_vers_html_camembert_elements_donnees_invalide( + exporteur, + donnees): + """ + Vérifie qu'une exception est levée lorsque le paramètre ``donnees`` n'est pas une liste + de listes. + + Scénarios testés: + - Passage d'une liste de données ne contenant pas de liste.. + + Asserts: + - Une exception :class:`ValueError` est levée. + + Args: + exporteur (Exporteur) : Fixture pour l'instance de la classe :class:`Exporteur`. + donnees (any): Le nom du fichier HTML qui contient le camembert. + """ + with pytest.raises(ValueError): + exporteur.export_vers_html_camembert(donnees, "sortie.html") + +@pytest.mark.parametrize("donnees", [ + ([[1, 1, 1]]), ([[1]]), ([[]]) +]) +def test_exporteur_exception_export_vers_html_camembert_listes_non_2_elements_invalide( + exporteur, + donnees): + """ + Vérifie qu'une exception est levée lorsque la liste des données contient des listes + ne contenant pas deux éléments. + + Scénarios testés: + - Lancement de la méthode avec des listes incorrectes. + + Asserts: + - Une exception :class:`ValueError` est levée. + + Args: + exporteur (Exporteur) : Fixture pour l'instance de la classe :class:`Exporteur`. + donnees (dict): Les données à mettre sous forme de camembert. + """ + with pytest.raises(ValueError): + exporteur.export_vers_html_camembert(donnees, "sortie.html") + +@pytest.mark.parametrize("donnees, nom_fichier", [ + ([[200, 1], [404, 10]], "fichier.html"), + ([["test", 12], ["essaie", 50], ], "fichier.html") +]) +def test_exporteur_export_vers_html_camembert_valide(exporteur, + donnees, + nom_fichier): + """ + Vérifie qu'aucune exception n'est levée lorsque du déroulement normale + de la méthode. + + Scénarios testés: + - Lancement de la méthode avec des paramètres correctes. + + Asserts: + - Aucune exception n'est levée. + + Args: + exporteur (Exporteur) : Fixture pour l'instance de la classe :class:`Exporteur`. + donnees (dict): Les données à mettre sous forme de camembert. + nom_fichier (str): Le nom du fichier HTML du camembert. + """ + try: + exporteur.export_vers_html_camembert(donnees, nom_fichier) + except Exception: + pytest.fail("Aucune exception ne doit être levée ici") + +@pytest.mark.parametrize("exception", [ + (PermissionError("Pas les droits")), + (FileNotFoundError("Fichier non trouvé.")), + (Exception("Toutes exceptions")) +]) +def test_exporteur_export_vers_html_camembert_exception_exportation(exporteur, mocker, exception): + """ + Vérifie que la classe renvoie l'exception :class:`ExportationCamembertHtmlException` 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:`ExportationCamembertHtmlException` est levée. + + Args: + exporteur (Exporteur) : Fixture pour l'instance de la classe :class:`Exporteur`. + mocker (any): Une fixture pour simuler des exceptions. + exception (any): L'exception levée dans la méthode. + """ + mocker.patch("altair.Chart.save", side_effect=exception) + with pytest.raises(ExportationCamembertHtmlException): + exporteur.export_vers_html_camembert([[200, 1], [404, 3]], "fichier.html") diff --git a/tests/test_parseur_arguments_cli.py b/tests/test_parseur_arguments_cli.py index 84c5688..aa63c23 100644 --- a/tests/test_parseur_arguments_cli.py +++ b/tests/test_parseur_arguments_cli.py @@ -22,9 +22,9 @@ ] sorties_valides = [ - "fichier.json", - "./fichier.json", - "C:/Users/fest/fichier.json" + "./", + "./dossier/", + "C:/Users/fest/dossier/" ] arguments_invalides = [ @@ -124,11 +124,11 @@ def test_parseur_cli_exception_chemin_log_invalide(parseur_arguments_cli, chemin @pytest.mark.parametrize("chemin_sortie", sorties_valides) def test_parseur_cli_recuperation_chemin_sortie_valide(parseur_arguments_cli, chemin_sortie): """ - Vérifie que le chemin du fichier de sortie JSON fourni depuis la ligne de commande est bien + Vérifie que le chemin du dossier de sortie fourni depuis la ligne de commande est bien récupéré par le parseur. Scénarios testés: - - Demande de parsage d'un chemin de fichier de sortie. + - Demande de parsage d'un chemin de dossier de sortie. Asserts: - La valeur du chemin de sortie est bien récupérée et conforme à l'entrée. @@ -144,11 +144,11 @@ def test_parseur_cli_recuperation_chemin_sortie_valide(parseur_arguments_cli, ch @pytest.mark.parametrize("chemin_sortie", chemins_invalides) def test_parseur_cli_exception_chemin_sortie_invalide(parseur_arguments_cli, chemin_sortie): """ - Vérifie qu'une erreur est retournée lorsque le chemin du fichier de sortie fourni contient + Vérifie qu'une erreur est retournée lorsque le chemin du dossier de sortie fourni contient au moins un caractère non autorisé. Scénarios testés: - - Demande de parsage d'un chemin de fichier de sortie invalide. + - Demande de parsage d'un chemin du dossier de sortie invalide. Asserts: - Une exception :class:`ArgumentCLIException` est levée. @@ -163,11 +163,11 @@ def test_parseur_cli_exception_chemin_sortie_invalide(parseur_arguments_cli, che def test_parseur_cli_recuperation_chemin_sortie_defaut_valide(parseur_arguments_cli): """ - Vérifie que le chemin du fichier de sortie JSON par défaut est bien appliqué lorsque - aucun chemin de sortie n'est donné. + Vérifie que le chemin du dossier de sortie par défaut est bien appliqué lorsque + aucun dossier de sortie n'est donné. Scénarios testés: - - Demande de parsage avec aucun fichier de sortie indiqué. + - Demande de parsage avec aucun dossier de sortie indiqué. Asserts: - La bonne valeur par défaut pour le chemin de sortie à été appliquée. @@ -177,43 +177,7 @@ def test_parseur_cli_recuperation_chemin_sortie_defaut_valide(parseur_arguments_ de la classe :class:`ParseurArgumentsCLI`. """ argument = parseur_arguments_cli.parse_args(args=["fichier.txt"]) - assert argument.sortie == "./analyse-log-apache.json" - -def test_parseur_cli_verification_extention_chemin_sortie(parseur_arguments_cli): - """ - Vérifie qu'une erreur est retournée lorsque le fichier de sortie fourni ne possède - pas l'extension '.json'. - - Scénarios testés: - - Demande de parsage d'un fichier de sortie qui n'est pas un fichier .json. - - Asserts: - - Une exception :class:`ArgumentCLIException` est levée. - - Args: - parseur_arguments_cli (ParseurArgumentsCLI): Fixture pour l'instance - de la classe :class:`ParseurArgumentsCLI`. - """ - with pytest.raises(ArgumentCLIException): - parseur_arguments_cli.parse_args(args=["fichier.txt", "-s", "invalide.txt"]) - -def test_parseur_cli_recuperation_chemin_sortie_defaut_valide(parseur_arguments_cli): - """ - Vérifie que le chemin du fichier de sortie JSON par défaut est bien appliqué lorsque - aucun chemin de sortie n'est donné. - - Scénarios testés: - - Demande de parsage avec aucun fichier de sortie indiqué. - - Asserts: - - La bonne valeur par défaut pour le chemin de sortie à été appliquée. - - Args: - parseur_arguments_cli (ParseurArgumentsCLI): Fixture pour l'instance - de la classe :class:`ParseurArgumentsCLI`. - """ - argument = parseur_arguments_cli.parse_args(args=["fichier.txt"]) - assert argument.sortie == "./analyse-log-apache.json" + assert argument.sortie == "./" @pytest.mark.parametrize("adresse_ip", [ ("127.0.0.1"), ("192.168.0.0"), ("10.0.0.8")