Merge branch 'main' of github.com:maoakeEnterprise/amazing

config.txt

@@ -3,4 +3,4 @@ HEIGHT=100
 ENTRY=0,0
 EXIT=19,14
 OUTPUT_FILE=maze.txt
-PERFECT=Truee
+PERFECT=True

src/parsing/Parsing.py

@@ -1,14 +1,11 @@
 class DataMaze:
 
     @staticmethod
-    def get_data(name_file: str) -> str:
+    def get_file_data(name_file: str) -> str:
-        data = ""
-        try:
         with open(name_file, "r") as file:
             data = file.read()
-        except FileNotFoundError:
+        if data == "":
-            print("The file do not exist")
+            raise ValueError("The file is empty")
-        finally:
         return data
 
     @staticmethod
@@ -23,32 +20,25 @@ 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")
+            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 Exception("Some Key "
+            raise KeyError("Some Key "
                            f"do not correspond the keys: {res_key}")
-            return data
-        except Exception as e:
-            print(f"{e}")
-            exit()
 
     @staticmethod
-    def verif_value_data(data: dict):
+    def convert_values(data: dict):
         key_int = {"WIDTH", "HEIGHT"}
         key_tuple = {"ENTRY", "EXIT"}
         key_bool = {"PERFECT"}
-        try:
         res: dict = {}
         for key in key_int:
             res.update({key: int(data[key])})
@@ -56,30 +46,52 @@ class DataMaze:
             res.update({key: DataMaze.convert_tuple(data[key])})
         for key in key_bool:
             res.update({key: DataMaze.convert_bool(data[key])})
+        res.update({"OUTPUT_FILE": data["OUTPUT_FILE"]})
         return res
-        except ValueError as e:
-            print("Error on the method verif_value_data"
-                  f" in the class DataMaze: {e}")
 
     @staticmethod
-    def convert_tuple(data: str) -> tuple:
+    def get_data_maze(name_file: str) -> dict:
         try:
-            data_t = data.split(",")
+            data_str = DataMaze.get_file_data(name_file)
-            x, y = data_t
+            data_dict = DataMaze.transform_data(data_str)
-            tup = (int(x), int(y))
+            DataMaze.verif_key_data(data_dict)
-            return tup
+            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(f"On the convert Tuple: {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:
+        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()

tests/test_parsing.py

@@ -1,14 +1,78 @@
 from parsing.Parsing import DataMaze
+import pytest
 
 
-def main() -> None:
+class TestParsing:
-    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)
 
+    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__":
+    def test_file_error(self):
-    main()
+        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
+
+    def test_data_maze(self):
+        data = DataMaze.get_data_maze("tests/test_txt/config_1.txt")
+        assert data["WIDTH"] == 200
+        assert data["HEIGHT"] == 100
+        assert data["ENTRY"] == (0, 0)
+        assert data["EXIT"] == (19, 14)
+        assert data["OUTPUT_FILE"] == "maze.txt"
+        assert data["PERFECT"] is True

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

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

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

tests/test_txt/error_8.txt

@@ -0,0 +1,4 @@
+WIDTH=200
+HEIGHT=100
+ENTRY=0,0
+EXIT=19,14

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