diff --git a/Makefile b/Makefile
index e33d978..7027e1d 100644
--- a/Makefile
+++ b/Makefile
@@ -18,5 +18,5 @@ lint-strict:
 	uv run flake8 .
 	uv run mypy . --strict
 
-run_test:
-	PYTHONPATH=src uv run python3 test/test_parsing.py
+run_test_parsing:
+	PYTHONPATH=src uv run pytest tests/test_parsing.py
diff --git a/config.txt b/config.txt
index 32a818a..748b11e 100644
--- a/config.txt
+++ b/config.txt
@@ -3,4 +3,4 @@ HEIGHT=100
 ENTRY=0,0
 EXIT=19,14
 OUTPUT_FILE=maze.txt
-PERFECT=Truee
\ No newline at end of file
+PERFECT=True
\ No newline at end of file
diff --git a/src/parsing/Parsing.py b/src/parsing/Parsing.py
index ca1cf8e..2ffd651 100644
--- a/src/parsing/Parsing.py
+++ b/src/parsing/Parsing.py
@@ -1,15 +1,12 @@
 class DataMaze:
 
     @staticmethod
-    def get_data(name_file: str) -> str:
-        data = ""
-        try:
-            with open(name_file, "r") as file:
-                data = file.read()
-        except FileNotFoundError:
-            print("The file do not exist")
-        finally:
-            return data
+    def get_file_data(name_file: str) -> str:
+        with open(name_file, "r") as file:
+            data = file.read()
+        if data == "":
+            raise ValueError("The file is empty")
+        return data
 
     @staticmethod
     def transform_data(data: str) -> dict:
@@ -23,63 +20,77 @@ class DataMaze:
         return data_t
 
     @staticmethod
-    def verif_key_data(data: dict) -> dict:
+    def verif_key_data(data: dict) -> None:
         key_test = {
             "WIDTH", "HEIGHT", "ENTRY", "EXIT", "OUTPUT_FILE", "PERFECT"
         }
         set_key = {
             key for key in data.keys()
         }
-        try:
-            res_key = {}
-            if len(set_key) != len(key_test):
-                raise Exception("Missing some data the len do not correspond")
-            res_key = {key for key in set_key if key not in key_test}
-            if len(res_key) != 0:
-                raise Exception("Some Key "
-                                f"do not correspond the keys: {res_key}")
-            return data
-        except Exception as e:
-            print(f"{e}")
-            exit()
+        if len(set_key) != len(key_test):
+            raise KeyError("Missing some data the len do not correspond")
+        res_key = {key for key in set_key if key not in key_test}
+        if len(res_key) != 0:
+            raise KeyError("Some Key "
+                           f"do not correspond the keys: {res_key}")
 
     @staticmethod
-    def verif_value_data(data: dict):
+    def convert_values(data: dict):
         key_int = {"WIDTH", "HEIGHT"}
         key_tuple = {"ENTRY", "EXIT"}
         key_bool = {"PERFECT"}
+        res: dict = {}
+        for key in key_int:
+            res.update({key: int(data[key])})
+        for key in key_tuple:
+            res.update({key: DataMaze.convert_tuple(data[key])})
+        for key in key_bool:
+            res.update({key: DataMaze.convert_bool(data[key])})
+        return res
+
+    @staticmethod
+    def get_data_maze(name_file: str) -> dict:
         try:
-            res: dict = {}
-            for key in key_int:
-                res.update({key: int(data[key])})
-            for key in key_tuple:
-                res.update({key: DataMaze.convert_tuple(data[key])})
-            for key in key_bool:
-                res.update({key: DataMaze.convert_bool(data[key])})
-            return res
+            data_str = DataMaze.get_file_data(name_file)
+            data_dict = DataMaze.transform_data(data_str)
+            DataMaze.verif_key_data(data_dict)
+            data_maze = DataMaze.convert_values(data_dict)
+            return data_maze
+        except FileNotFoundError:
+            print("The file do not exist")
+            exit()
+        except PermissionError:
+            print("We dont have the Permission")
+            exit()
         except ValueError as e:
-            print("Error on the method verif_value_data"
-                  f" in the class DataMaze: {e}")
+            print(f"Error during the convert or the file is empty: {e}")
+            exit()
+        except KeyError as e:
+            print(f"Error on the key in the file: {e}")
+            exit()
+        except IndexError as e:
+            print("In the function transform Data some data cannot "
+                  f"be splited by '=' because '=' was not present: {e}")
+            exit()
+        except AttributeError as e:
+            print("Error on the "
+                  f"funciton get_data_maze : {e}")
+            exit()
 
     @staticmethod
     def convert_tuple(data: str) -> tuple:
-        try:
-            data_t = data.split(",")
-            x, y = data_t
-            tup = (int(x), int(y))
-            return tup
-        except ValueError as e:
-            print(f"On the convert Tuple: {e}")
-            exit()
+        data_t = data.split(",")
+        if len(data_t) != 2:
+            raise ValueError("There is too much "
+                             "argument in the coordinate given")
+        x, y = data_t
+        tup = (int(x), int(y))
+        return tup
 
     @staticmethod
     def convert_bool(data: str) -> bool:
-        try:
-            if data != "True" and data != "False":
-                raise ValueError("This is not True or False")
-            if data == "True":
-                return True
-            return False
-        except ValueError as e:
-            print(f"Error on the convert_bool in class DataMaze: {e}")
-            exit()
+        if data != "True" and data != "False":
+            raise ValueError("This is not True or False")
+        if data == "True":
+            return True
+        return False
diff --git a/tests/test_parsing.py b/tests/test_parsing.py
index df6c6d7..b396758 100644
--- a/tests/test_parsing.py
+++ b/tests/test_parsing.py
@@ -1,14 +1,69 @@
 from parsing.Parsing import DataMaze
+import pytest
 
 
-def main() -> None:
-    print("Unit Testing for parsing:")
-    data = DataMaze.get_data("config.txt")
-    data_t = DataMaze.transform_data(data)
-    data_t = DataMaze.verif_key_data(data_t)
-    data_t = DataMaze.verif_value_data(data_t)
-    print(data_t)
+class TestParsing:
 
+    def test_get_data_valid(self):
+        data = DataMaze.get_file_data("tests/test_txt/config_1.txt")
+        assert isinstance(data, str) is True
 
-if __name__ == "__main__":
-    main()
+    def test_file_error(self):
+        with pytest.raises(FileNotFoundError):
+            DataMaze.get_file_data("tete")
+
+    def test_permission_error(self):
+        with pytest.raises(PermissionError):
+            DataMaze.get_file_data("tests/test_txt/error_1.txt")
+
+    def test_empty_file_error(self):
+        with pytest.raises(ValueError):
+            DataMaze.get_file_data("tests/test_txt/error_6.txt")
+
+    def test_transform_data_valid(self):
+        data = DataMaze.get_file_data("tests/test_txt/config_1.txt")
+        data_2 = DataMaze.transform_data(data)
+        assert isinstance(data_2, dict)
+
+    def test_transform__index_error(self):
+        with pytest.raises(IndexError):
+            DataMaze.transform_data("asdasdasdasdasdasda\nasdasdas=asdasd")
+
+    def test_key_data_error(self):
+        with pytest.raises(KeyError):
+            data = DataMaze.get_file_data("tests/test_txt/error_8.txt")
+            data2 = DataMaze.transform_data(data)
+            DataMaze.verif_key_data(data2)
+
+    def test_key_data_error_2(self):
+        with pytest.raises(KeyError):
+            data = DataMaze.get_file_data("tests/test_txt/error_9.txt")
+            data2 = DataMaze.transform_data(data)
+            DataMaze.verif_key_data(data2)
+
+    def test_convert_int(self):
+        with pytest.raises(ValueError):
+            data = DataMaze.get_file_data("tests/test_txt/error_2.txt")
+            data2 = DataMaze.transform_data(data)
+            DataMaze.convert_values(data2)
+
+    def test_tuple_error(self):
+        with pytest.raises(ValueError):
+            DataMaze.convert_tuple("0,3,5,5")
+
+    def test_tuple_error1(self):
+        with pytest.raises(AttributeError):
+            DataMaze.convert_tuple(None)
+
+    def test_bool_error(self):
+        with pytest.raises(ValueError):
+            DataMaze.convert_bool("Trueeee")
+
+    def test_valid_tuple(self):
+        assert DataMaze.convert_tuple("7534564654, 78") == (7534564654, 78)
+
+    def test_valid_bool(self):
+        assert DataMaze.convert_bool("False") is False
+
+    def test_valid_bool1(self):
+        assert DataMaze.convert_bool("True") is True
diff --git a/tests/test_txt/config_1.txt b/tests/test_txt/config_1.txt
new file mode 100644
index 0000000..748b11e
--- /dev/null
+++ b/tests/test_txt/config_1.txt
@@ -0,0 +1,6 @@
+WIDTH=200
+HEIGHT=100
+ENTRY=0,0
+EXIT=19,14
+OUTPUT_FILE=maze.txt
+PERFECT=True
\ No newline at end of file
diff --git a/tests/test_txt/error_1.txt b/tests/test_txt/error_1.txt
new file mode 100644
index 0000000..748b11e
--- /dev/null
+++ b/tests/test_txt/error_1.txt
@@ -0,0 +1,6 @@
+WIDTH=200
+HEIGHT=100
+ENTRY=0,0
+EXIT=19,14
+OUTPUT_FILE=maze.txt
+PERFECT=True
\ No newline at end of file
diff --git a/tests/test_txt/error_2.txt b/tests/test_txt/error_2.txt
new file mode 100644
index 0000000..8966c8f
--- /dev/null
+++ b/tests/test_txt/error_2.txt
@@ -0,0 +1,6 @@
+WIDTH=caca
+HEIGHT=100
+ENTRY=0,0
+EXIT=19,14
+OUTPUT_FILE=maze.txt
+PERFECT=True
\ No newline at end of file
diff --git a/tests/test_txt/error_6.txt b/tests/test_txt/error_6.txt
new file mode 100644
index 0000000..e69de29
diff --git a/tests/test_txt/error_8.txt b/tests/test_txt/error_8.txt
new file mode 100644
index 0000000..784140a
--- /dev/null
+++ b/tests/test_txt/error_8.txt
@@ -0,0 +1,4 @@
+WIDTH=200
+HEIGHT=100
+ENTRY=0,0
+EXIT=19,14
\ No newline at end of file
diff --git a/tests/test_txt/error_9.txt b/tests/test_txt/error_9.txt
new file mode 100644
index 0000000..8476a89
--- /dev/null
+++ b/tests/test_txt/error_9.txt
@@ -0,0 +1,7 @@
+WIDTH=200
+HEIGHT=100
+ENTRY=0,0
+EXIT=19,14
+OUTPUT_FILE=maze.txt
+PERFECT=True
+PIPI=tut
\ No newline at end of file