#1714: refactor private attributes and made them public + serialisation tests

src/primaite/simulator/file_system/file_system.py

@@ -1,7 +1,5 @@
 from typing import Dict, List, Optional
 
-from pydantic import PrivateAttr
-
 from primaite.simulator.core import SimComponent
 from primaite.simulator.file_system.file_system_file import FileSystemFile
 from primaite.simulator.file_system.file_system_file_type import FileSystemFileType
@@ -11,7 +9,7 @@ from primaite.simulator.file_system.file_system_folder import FileSystemFolder
 class FileSystem(SimComponent):
     """Class that contains all the simulation File System."""
 
-    _folders: List[FileSystemFolder] = PrivateAttr([])
+    folders: List[FileSystemFolder] = []
     """List containing all the folders in the file system."""
 
     def describe_state(self) -> Dict:
@@ -24,7 +22,7 @@ class FileSystem(SimComponent):
 
     def get_folders(self) -> List[FileSystemFolder]:
         """Returns the list of folders."""
-        return self._folders
+        return self.folders
 
     def create_file(self, file_size: float, folder_uuid: Optional[str] = None) -> FileSystemFile:
         """
@@ -40,7 +38,7 @@ class FileSystem(SimComponent):
 
             file = FileSystemFile(item_parent=folder.uuid, file_size=file_size, file_type=FileSystemFileType.TBD)
             folder.add_file(file)
-            self._folders.append(folder)
+            self.folders.append(folder)
         else:
             # otherwise check for existence and add file
             folder = self.get_folder_by_id(folder_uuid)
@@ -52,7 +50,7 @@ class FileSystem(SimComponent):
     def create_folder(self) -> FileSystemFolder:
         """Creates a FileSystemFolder and adds it to the list of folders."""
         folder = FileSystemFolder(item_parent=None)
-        self._folders.append(folder)
+        self.folders.append(folder)
         return folder
 
     def delete_file(self, file_id: str):
@@ -63,7 +61,7 @@ class FileSystem(SimComponent):
         :type file_id: str
         """
         # iterate through folders to delete the item with the matching uuid
-        for folder in self._folders:
+        for folder in self.folders:
             folder.remove_file(file_id)
 
     def delete_folder(self, folder_id: str):
@@ -73,7 +71,7 @@ class FileSystem(SimComponent):
         :param folder_id: The UUID of the file item to delete
         :type folder_id: str
         """
-        self._folders = list(filter(lambda f: (f.uuid != folder_id), self._folders))
+        self.folders = list(filter(lambda f: (f.uuid != folder_id), self.folders))
 
     def move_file(self, src_folder_id: str, target_folder_id: str, file_id: str):
         """Moves a file from one folder to another."""
@@ -118,11 +116,11 @@ class FileSystem(SimComponent):
 
     def get_file_by_id(self, file_id: str) -> FileSystemFile:
         """Checks if the file exists in any file system folders."""
-        for folder in self._folders:
+        for folder in self.folders:
             file = folder.get_file(file_id=file_id)
             if file is not None:
                 return file
 
     def get_folder_by_id(self, folder_id: str) -> FileSystemFolder:
         """Checks if the folder exists."""
-        return next((f for f in self._folders if f.uuid == folder_id), None)
+        return next((f for f in self.folders if f.uuid == folder_id), None)

src/primaite/simulator/file_system/file_system_file.py

@@ -1,7 +1,6 @@
+from random import choice, random
 from typing import Dict
 
-from pydantic import PrivateAttr
-
 from primaite.simulator.core import SimComponent
 from primaite.simulator.file_system.file_system_file_type import FileSystemFileType
 
@@ -9,34 +8,42 @@ from primaite.simulator.file_system.file_system_file_type import FileSystemFileT
 class FileSystemFile(SimComponent):
     """Class that represents a file in the simulation."""
 
-    _file_type: FileSystemFileType = PrivateAttr()
+    file_type: FileSystemFileType = None
     """The type of the FileSystemFile"""
 
-    _file_size: float = PrivateAttr()
+    file_size: float = 0
     """Disk size of the FileSystemItem"""
 
-    def __init__(self, file_type: FileSystemFileType, file_size: float, **kwargs):
+    def __init__(self, **kwargs):
         """
         Initialise FileSystemFile class.
 
-        :param item_parent: The UUID of the FileSystemItem parent
-        :type item_parent: str
+        :param file_type: The FileSystemFileType of the file
+        :type file_type: Optional[FileSystemFileType]
 
         :param file_size: The size of the FileSystemItem
-        :type file_size: float
+        :type file_size: Optional[float]
         """
         super().__init__(**kwargs)
 
-        self._file_type = file_type
-        self._file_size = file_size
+        self.file_type = choice(list(FileSystemFileType))
+        self.file_size = random()
+
+        # set random file size if non provided
+        if kwargs.get("file_size") is not None:
+            self.file_size = kwargs.get("file_size")
+
+        # set random file type if none provided
+        if kwargs.get("file_type") is None:
+            self.file_type = kwargs.get("file_type")
 
     def get_file_size(self) -> float:
         """Returns the size of the file system item."""
-        return self._file_size
+        return self.file_size
 
     def get_file_type(self) -> FileSystemFileType:
         """Returns the FileSystemFileType of the file."""
-        return self._file_type
+        return self.file_type
 
     def describe_state(self) -> Dict:
         """

src/primaite/simulator/file_system/file_system_folder.py

@@ -1,7 +1,5 @@
 from typing import Dict, List
 
-from pydantic import PrivateAttr
-
 from primaite.simulator.core import SimComponent
 from primaite.simulator.file_system.file_system_file import FileSystemFile
 
@@ -9,53 +7,53 @@ from primaite.simulator.file_system.file_system_file import FileSystemFile
 class FileSystemFolder(SimComponent):
     """Simulation FileSystemFolder."""
 
-    _files: List[FileSystemFile] = PrivateAttr([])
+    files: List[FileSystemFile] = []
     """List of files stored in the folder."""
 
-    _folder_size: float = PrivateAttr(0)
+    folder_size: float = 0
     """The current size of the folder"""
 
-    _is_quarantined: bool = PrivateAttr(False)
+    is_quarantined: bool = False
     """Flag that marks the folder as quarantined if true."""
 
     def get_files(self) -> List[FileSystemFile]:
         """Returns the list of files the folder contains."""
-        return self._files
+        return self.files
 
     def get_file(self, file_id: str) -> FileSystemFile:
         """Return a FileSystemFile with the matching id."""
-        return next((f for f in self._files if f.uuid == file_id), None)
+        return next((f for f in self.files if f.uuid == file_id), None)
 
     def add_file(self, file: FileSystemFile):
         """Adds a file to the folder list."""
-        self._folder_size += file.get_file_size()
+        self.folder_size += file.get_file_size()
 
         # add to list
-        self._files.append(file)
+        self.files.append(file)
 
     def remove_file(self, file_id: str):
         """Removes a file from the folder list."""
-        file = next((f for f in self._files if f.uuid == file_id), None)
-        self._files.remove(file)
+        file = next((f for f in self.files if f.uuid == file_id), None)
+        self.files.remove(file)
 
         # remove folder size from folder
-        self._folder_size -= file.get_file_size()
+        self.folder_size -= file.get_file_size()
 
     def get_folder_size(self) -> float:
         """Returns a sum of all file sizes in the files list."""
-        return sum([file.get_file_size() for file in self._files])
+        return sum([file.get_file_size() for file in self.files])
 
     def quarantine(self):
         """Quarantines the File System Folder."""
-        self._is_quarantined = True
+        self.is_quarantined = True
 
     def end_quarantine(self):
         """Ends the quarantine of the File System Folder."""
-        self._is_quarantined = False
+        self.is_quarantined = False
 
     def quarantine_status(self) -> bool:
         """Returns true if the folder is being quarantined."""
-        return self._is_quarantined
+        return self.is_quarantined
 
     def describe_state(self) -> Dict:
         """

tests/unit_tests/_primaite/_simulator/_file_system/test_file_system.py

@@ -78,3 +78,18 @@ def test_copy_file():
 
     assert len(file_system.get_folder_by_id(src_folder.uuid).get_files()) is 1
     assert len(file_system.get_folder_by_id(target_folder.uuid).get_files()) is 1
+
+
+def test_serialisation():
+    """Test to check that the object serialisation works correctly."""
+    file_system = FileSystem()
+    folder = file_system.create_folder()
+    assert len(file_system.get_folders()) is 1
+
+    file_system.create_file(file_size=10, folder_uuid=folder.uuid)
+    assert len(file_system.get_folders()[0].get_files()) is 1
+
+    serialised_file_sys = file_system.model_dump_json()
+    deserialised_file_sys = FileSystem().model_validate_json(serialised_file_sys)
+
+    assert file_system == deserialised_file_sys

tests/unit_tests/_primaite/_simulator/_file_system/test_file_system_file.py

@@ -12,3 +12,12 @@ def test_get_file_size():
     """Tests that the file size is being returned properly."""
     file = FileSystemFile(file_size=1.5, file_type=FileSystemFileType.TBD)
     assert file.get_file_size() is 1.5
+
+
+def test_serialisation():
+    """Test to check that the object serialisation works correctly."""
+    file = FileSystemFile(file_size=1.5, file_type=FileSystemFileType.TBD)
+    serialised_file = file.model_dump_json()
+    deserialised_file = FileSystemFile().model_validate_json(serialised_file)
+
+    assert file == deserialised_file

tests/unit_tests/_primaite/_simulator/_file_system/test_file_system_folder.py

@@ -4,6 +4,7 @@ from primaite.simulator.file_system.file_system_folder import FileSystemFolder
 
 
 def test_adding_removing_file():
+    """Test the adding and removing of a file from a folder."""
     folder = FileSystemFolder()
 
     file = FileSystemFile(file_size=10, file_type=FileSystemFileType.TBD)
@@ -18,18 +19,22 @@ def test_adding_removing_file():
 
 
 def test_get_file_by_id():
+    """Test to make sure that the correct file is returned."""
     folder = FileSystemFolder()
 
     file = FileSystemFile(file_size=10, file_type=FileSystemFileType.TBD)
+    file2 = FileSystemFile(file_size=10, file_type=FileSystemFileType.TBD)
 
     folder.add_file(file)
-    assert folder.get_folder_size() is 10
-    assert len(folder.get_files()) is 1
+    folder.add_file(file2)
+    assert folder.get_folder_size() is 20
+    assert len(folder.get_files()) is 2
 
     assert folder.get_file(file_id=file.uuid) is file
 
 
 def test_folder_quarantine_state():
+    """Tests the changing of folder quarantine status."""
     folder = FileSystemFolder()
 
     assert folder.quarantine_status() is False
@@ -39,3 +44,16 @@ def test_folder_quarantine_state():
 
     folder.end_quarantine()
     assert folder.quarantine_status() is False
+
+
+def test_serialisation():
+    """Test to check that the object serialisation works correctly."""
+    folder = FileSystemFolder()
+    file = FileSystemFile(file_size=10, file_type=FileSystemFileType.TBD)
+    folder.add_file(file)
+
+    serialised_folder = folder.model_dump_json()
+
+    deserialised_folder = FileSystemFolder().model_validate_json(serialised_folder)
+
+    assert folder == deserialised_folder