pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/tests/core/files/test_clients.py

@@ -0,0 +1,128 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+import json
+
+from pygeai.core.files.clients import FileClient
+
+
+class TestFileClient(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.files.test_clients.TestFileClient
+    """
+    def setUp(self):
+        self.file_client = FileClient()
+        self.organization_id = "org123"
+        self.project_id = "proj123"
+        self.file_id = "file456"
+        self.file_path = Path("test_file.txt")
+        self.mock_response = MagicMock()
+        self.mock_response.json.return_value = {"id": self.file_id, "status": "success"}
+        self.mock_response.status_code = 200
+        self.mock_response.text = json.dumps({"id": self.file_id, "status": "success"})
+        self.mock_response.content = b"file content"
+        self.mock_file = MagicMock()
+        self.mock_file.close = MagicMock()
+
+    @patch('pygeai.core.services.rest.ApiService.post_files_multipart')
+    @patch('pathlib.Path.is_file')
+    @patch('pathlib.Path.open')
+    def test_upload_file_success(self, mock_open, mock_is_file, mock_post):
+        mock_is_file.return_value = True
+        mock_open.return_value = self.mock_file
+        mock_post.return_value = self.mock_response
+
+        result = self.file_client.upload_file(
+            file_path=str(self.file_path),
+            organization_id=self.organization_id,
+            project_id=self.project_id,
+            folder="test_folder",
+            file_name="custom_name.txt"
+        )
+
+        mock_post.assert_called_once()
+        mock_is_file.assert_called_once()
+        mock_open.assert_called_once_with("rb")
+        self.mock_file.close.assert_called_once()
+        self.assertEqual(result, {"id": self.file_id, "status": "success"})
+
+    @patch('pygeai.core.services.rest.ApiService.post_files_multipart')
+    @patch('pathlib.Path.is_file')
+    @patch('pathlib.Path.open')
+    def test_upload_file_without_optional_params(self, mock_open, mock_is_file, mock_post):
+        mock_is_file.return_value = True
+        mock_open.return_value = self.mock_file
+        mock_post.return_value = self.mock_response
+
+        result = self.file_client.upload_file(
+            file_path=str(self.file_path),
+            organization_id=self.organization_id,
+            project_id=self.project_id
+        )
+
+        mock_post.assert_called_once()
+        mock_is_file.assert_called_once()
+        mock_open.assert_called_once_with("rb")
+        self.mock_file.close.assert_called_once()
+        self.assertEqual(result, {"id": self.file_id, "status": "success"})
+
+    def test_upload_file_not_found(self):
+        with self.assertRaises(FileNotFoundError):
+            self.file_client.upload_file(
+                file_path="nonexistent_file.txt",
+                organization_id=self.organization_id,
+                project_id=self.project_id
+            )
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_file_success(self, mock_get):
+        mock_get.return_value = self.mock_response
+
+        result = self.file_client.get_file(
+            organization=self.organization_id,
+            project=self.project_id,
+            file_id=self.file_id
+        )
+
+        mock_get.assert_called_once()
+        self.assertEqual(result, {"id": self.file_id, "status": "success"})
+
+    @patch('pygeai.core.services.rest.ApiService.delete')
+    def test_delete_file_success(self, mock_delete):
+        mock_delete.return_value = self.mock_response
+
+        result = self.file_client.delete_file(
+            organization=self.organization_id,
+            project=self.project_id,
+            file_id=self.file_id
+        )
+
+        mock_delete.assert_called_once()
+        self.assertEqual(result, {"id": self.file_id, "status": "success"})
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_file_content_success(self, mock_get):
+        mock_get.return_value = self.mock_response
+
+        result = self.file_client.get_file_content(
+            organization=self.organization_id,
+            project=self.project_id,
+            file_id=self.file_id
+        )
+
+        mock_get.assert_called_once()
+        self.assertEqual(result, b"file content")
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_get_file_list_success(self, mock_get):
+        mock_get.return_value = self.mock_response
+
+        result = self.file_client.get_file_list(
+            organization=self.organization_id,
+            project=self.project_id
+        )
+
+        mock_get.assert_called_once()
+        self.assertEqual(result, {"id": self.file_id, "status": "success"})
+
+

pygeai/tests/core/files/test_managers.py

@@ -1,19 +1,16 @@
 import unittest
-from unittest.mock import MagicMock
-from pygeai.core.base.mappers import ErrorMapper, ResponseMapper
-from pygeai.core.files.mappers import FileResponseMapper
-from pygeai.core.files.responses import UploadFileResponse
-from pygeai.core.files.models import UploadFile, File, FileList
-from pygeai.core.files.clients import FileClient
-from pygeai.core.base.responses import EmptyResponse, ErrorListResponse
+from unittest.mock import MagicMock, patch
 from pygeai.core.files.managers import FileManager
+from pygeai.core.files.models import UploadFile, File, FileList
+from pygeai.core.files.responses import UploadFileResponse
+from pygeai.core.base.responses import EmptyResponse
+from pygeai.core.common.exceptions import APIError
 
 
 class TestFileManager(unittest.TestCase):
     """
     python -m unittest pygeai.tests.core.files.test_managers.TestFileManager
     """
-
     def setUp(self):
         self.api_key = "dummy_api_key"
         self.base_url = "https://dummyapi.com"
@@ -25,7 +22,7 @@ class TestFileManager(unittest.TestCase):
             organization_id=self.organization_id,
             project_id=self.project_id
         )
-        self.file_client_mock = MagicMock(spec=FileClient)
+        self.file_client_mock = MagicMock()
         self.file_manager._FileManager__client = self.file_client_mock
 
     def test_upload_file_success(self):
@@ -36,20 +33,27 @@ class TestFileManager(unittest.TestCase):
             'success': True
         }
         self.file_client_mock.upload_file.return_value = mock_response
-
-        result = self.file_manager.upload_file(file)
-
-        self.assertIsInstance(result, UploadFileResponse)
-        self.assertEqual(result.id, "30120d96-6d3b-40ae-887d-8a7485f8ba02")
-        self.assertEqual(result.url,
-                         'filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt')
-        self.file_client_mock.upload_file.assert_called_once_with(
-            file_path=file.path,
-            organization_id=self.organization_id,
-            project_id=self.project_id,
-            folder=file.folder,
-            file_name=file.name
-        )
+        with patch('pygeai.core.files.managers.FileResponseMapper.map_to_upload_file_response') as mock_mapper:
+            mock_mapper.return_value = UploadFileResponse(
+                id="30120d96-6d3b-40ae-887d-8a7485f8ba02",
+                url="filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt",
+                success=True
+            )
+
+            result = self.file_manager.upload_file(file)
+
+            self.assertIsInstance(result, UploadFileResponse)
+            self.assertEqual(result.id, "30120d96-6d3b-40ae-887d-8a7485f8ba02")
+            self.assertEqual(result.url,
+                             'filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt')
+            self.file_client_mock.upload_file.assert_called_once_with(
+                file_path=file.path,
+                organization_id=self.organization_id,
+                project_id=self.project_id,
+                folder=file.folder,
+                file_name=file.name
+            )
+            mock_mapper.assert_called_once_with(mock_response)
 
     def test_get_file_data_success(self):
         file_id = "9984b837-fe88-4014-ad14-91e1596c8ead"
@@ -65,36 +69,48 @@ class TestFileManager(unittest.TestCase):
             'success': True
         }
         self.file_client_mock.get_file.return_value = mock_response
-
-        result = self.file_manager.get_file_data(file_id)
-
-        self.assertIsInstance(result, File)
-        self.assertEqual(result.id, "9984b837-fe88-4014-ad14-91e1596c8ead")
-        self.assertEqual(result.name, "TestyFile")
-        self.assertEqual(result.extension, "txt")
-        self.assertEqual(result.purpose, "Assistant")
-        self.assertEqual(result.size, 19)
-        self.assertEqual(result.url,
-                         "filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt")
-        self.file_client_mock.get_file.assert_called_once_with(
-            organization=self.organization_id,
-            project=self.project_id,
-            file_id=file_id
-        )
+        with patch('pygeai.core.files.managers.FileResponseMapper.map_to_file') as mock_mapper:
+            mock_mapper.return_value = File(
+                id="9984b837-fe88-4014-ad14-91e1596c8ead",
+                name="TestyFile",
+                extension="txt",
+                purpose="Assistant",
+                size=19,
+                url="filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt"
+            )
+
+            result = self.file_manager.get_file_data(file_id)
+
+            self.assertIsInstance(result, File)
+            self.assertEqual(result.id, "9984b837-fe88-4014-ad14-91e1596c8ead")
+            self.assertEqual(result.name, "TestyFile")
+            self.assertEqual(result.extension, "txt")
+            self.assertEqual(result.purpose, "Assistant")
+            self.assertEqual(result.size, 19)
+            self.assertEqual(result.url, "filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt")
+            self.file_client_mock.get_file.assert_called_once_with(
+                organization=self.organization_id,
+                project=self.project_id,
+                file_id=file_id
+            )
+            mock_mapper.assert_called_once_with(mock_response)
 
     def test_delete_file_success(self):
         file_id = "file123"
         mock_response = {}
         self.file_client_mock.delete_file.return_value = mock_response
+        with patch('pygeai.core.files.managers.ResponseMapper.map_to_empty_response') as mock_mapper:
+            mock_mapper.return_value = EmptyResponse()
 
-        result = self.file_manager.delete_file(file_id)
+            result = self.file_manager.delete_file(file_id)
 
-        self.assertIsInstance(result, EmptyResponse)
-        self.file_client_mock.delete_file.assert_called_once_with(
-            organization=self.organization_id,
-            project=self.project_id,
-            file_id=file_id
-        )
+            self.assertIsInstance(result, EmptyResponse)
+            self.file_client_mock.delete_file.assert_called_once_with(
+                organization=self.organization_id,
+                project=self.project_id,
+                file_id=file_id
+            )
+            mock_mapper.assert_called_once_with(mock_response or "File deleted successfully")
 
     def test_get_file_content_success(self):
         file_id = "file123"
@@ -130,44 +146,74 @@ class TestFileManager(unittest.TestCase):
             ]
         }
         self.file_client_mock.get_file_list.return_value = mock_response
-
-        result = self.file_manager.get_file_list()
-
-        self.assertIsInstance(result, FileList)
-        self.assertEqual(len(result.files), 2)
-        self.assertEqual(result.files[0].id, "30120d96-6d3b-40ae-887d-8a7485f8ba02")
-        self.assertEqual(result.files[0].name, "TestyFile")
-        self.assertEqual(result.files[0].extension, "txt")
-        self.assertEqual(result.files[0].size, 19)
-        self.assertEqual(result.files[0].url, "filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt")
-        self.assertEqual(result.files[1].id, "7433c276-81e8-405e-9990-82158326f839")
-        self.assertEqual(result.files[1].name, "TestyFile")
-        self.assertEqual(result.files[1].extension, "txt")
-        self.assertEqual(result.files[1].size, 19)
-        self.assertEqual(result.files[1].url, "filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt")
-
-        self.file_client_mock.get_file_list.assert_called_once_with(
-            organization=self.organization_id,
-            project=self.project_id
-        )
+        with patch('pygeai.core.files.managers.FileResponseMapper.map_to_file_list_response') as mock_mapper:
+            mock_mapper.return_value = FileList(files=[
+                File(
+                    id="30120d96-6d3b-40ae-887d-8a7485f8ba02",
+                    name="TestyFile",
+                    extension="txt",
+                    size=19,
+                    url="filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt"
+                ),
+                File(
+                    id="7433c276-81e8-405e-9990-82158326f839",
+                    name="TestyFile",
+                    extension="txt",
+                    size=19,
+                    url="filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt"
+                )
+            ])
+
+            result = self.file_manager.get_file_list()
+
+            self.assertIsInstance(result, FileList)
+            self.assertEqual(len(result.files), 2)
+            self.assertEqual(result.files[0].id, "30120d96-6d3b-40ae-887d-8a7485f8ba02")
+            self.assertEqual(result.files[0].name, "TestyFile")
+            self.assertEqual(result.files[0].extension, "txt")
+            self.assertEqual(result.files[0].size, 19)
+            self.assertEqual(result.files[0].url, "filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt")
+            self.assertEqual(result.files[1].id, "7433c276-81e8-405e-9990-82158326f839")
+            self.assertEqual(result.files[1].name, "TestyFile")
+            self.assertEqual(result.files[1].extension, "txt")
+            self.assertEqual(result.files[1].size, 19)
+            self.assertEqual(result.files[1].url, "filesAssistants/4aa15b61-d3c7-4a5c-99b8-052d18a04ff2/1956c032-3c66-4435-acb8-6a06e52f819f/files/TestyTestTemp/TestyFile.txt")
+            self.file_client_mock.get_file_list.assert_called_once_with(
+                organization=self.organization_id,
+                project=self.project_id
+            )
+            mock_mapper.assert_called_once_with(mock_response)
 
     def test_upload_file_error(self):
         file = UploadFile(path="dummy_path", name="test.txt", folder="folder1")
         mock_response = {"errors": [{"id": 1, "description": "Upload failed"}]}
         self.file_client_mock.upload_file.return_value = mock_response
+        with patch('pygeai.core.files.managers.ErrorHandler.has_errors', return_value=True):
+            with patch('pygeai.core.files.managers.ErrorHandler.extract_error', return_value="Upload failed"):
+                with self.assertRaises(APIError) as context:
+                    self.file_manager.upload_file(file)
+
+                self.assertIn("Error received while uploading file: Upload failed", str(context.exception))
+                self.file_client_mock.upload_file.assert_called_once_with(
+                    file_path=file.path,
+                    organization_id=self.organization_id,
+                    project_id=self.project_id,
+                    folder=file.folder,
+                    file_name=file.name
+                )
+
+    def test_get_file_content_error(self):
+        file_id = "file123"
+        mock_response = {"errors": [{"id": 1, "description": "Content retrieval failed"}]}
+        self.file_client_mock.get_file_content.return_value = mock_response
 
-        result = self.file_manager.upload_file(file)
-
-        self.assertIsInstance(result, ErrorListResponse)
-        self.assertEqual(len(result.errors), 1)
-        self.assertEqual(result.errors[0].id, 1)
-        self.assertEqual(result.errors[0].description, "Upload failed")
+        with self.assertRaises(APIError) as context:
+            self.file_manager.get_file_content(file_id)
 
-        self.file_client_mock.upload_file.assert_called_once_with(
-            file_path=file.path,
-            organization_id=self.organization_id,
-            project_id=self.project_id,
-            folder=file.folder,
-            file_name=file.name
+        self.assertIn("Error received while retrieving file content", str(context.exception))
+        self.file_client_mock.get_file_content.assert_called_once_with(
+            organization=self.organization_id,
+            project=self.project_id,
+            file_id=file_id
         )
 

pygeai/tests/core/files/test_mappers.py

@@ -0,0 +1,137 @@
+import unittest
+
+from pygeai.core.files.mappers import FileResponseMapper
+from pygeai.core.files.models import FileList, File
+from pygeai.core.files.responses import UploadFileResponse
+
+
+class TestFileResponseMapper(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.files.test_mappers.TestFileResponseMapper
+    """
+
+    def test_map_to_upload_file_response(self):
+        data = {
+            'dataFileId': 'file-123',
+            'dataFileUrl': 'https://example.com/file.txt',
+            'success': True
+        }
+        
+        result = FileResponseMapper.map_to_upload_file_response(data)
+        
+        self.assertIsInstance(result, UploadFileResponse)
+        self.assertEqual(result.id, 'file-123')
+        self.assertEqual(result.url, 'https://example.com/file.txt')
+        self.assertTrue(result.success)
+
+    def test_map_to_upload_file_response_missing_fields(self):
+        data = {}
+        
+        result = FileResponseMapper.map_to_upload_file_response(data)
+        
+        self.assertIsNone(result.id)
+        self.assertIsNone(result.url)
+        self.assertIsNone(result.success)
+
+    def test_map_to_file_list_response(self):
+        data = {
+            'dataFiles': [
+                {
+                    'dataFileId': 'file-1',
+                    'dataFileName': 'test1.txt',
+                    'dataFileExtension': 'txt',
+                    'dataFilePurpose': 'testing',
+                    'dataFileSize': 1024,
+                    'dataFileUrl': 'https://example.com/file1.txt'
+                },
+                {
+                    'dataFileId': 'file-2',
+                    'dataFileName': 'test2.pdf',
+                    'dataFileExtension': 'pdf',
+                    'dataFilePurpose': 'document',
+                    'dataFileSize': 2048,
+                    'dataFileUrl': 'https://example.com/file2.pdf'
+                }
+            ]
+        }
+        
+        result = FileResponseMapper.map_to_file_list_response(data)
+        
+        self.assertIsInstance(result, FileList)
+        self.assertEqual(len(result.files), 2)
+        self.assertEqual(result.files[0].id, 'file-1')
+        self.assertEqual(result.files[1].id, 'file-2')
+
+    def test_map_to_file_list_empty(self):
+        data = {'dataFiles': []}
+        
+        result = FileResponseMapper.map_to_file_list(data)
+        
+        self.assertEqual(result, [])
+
+    def test_map_to_file_list_none(self):
+        data = {}
+        
+        result = FileResponseMapper.map_to_file_list(data)
+        
+        self.assertEqual(result, [])
+
+    def test_map_to_file_lowercase_keys(self):
+        data = {
+            'dataFileId': 'file-1',
+            'dataFileName': 'test.txt',
+            'dataFileExtension': 'txt',
+            'dataFilePurpose': 'testing',
+            'dataFileSize': 1024,
+            'dataFileUrl': 'https://example.com/file.txt'
+        }
+        
+        result = FileResponseMapper.map_to_file(data)
+        
+        self.assertIsInstance(result, File)
+        self.assertEqual(result.id, 'file-1')
+        self.assertEqual(result.name, 'test.txt')
+        self.assertEqual(result.extension, 'txt')
+        self.assertEqual(result.purpose, 'testing')
+        self.assertEqual(result.size, 1024)
+        self.assertEqual(result.url, 'https://example.com/file.txt')
+
+    def test_map_to_file_uppercase_keys(self):
+        data = {
+            'DataFileId': 'file-2',
+            'DataFileName': 'document.pdf',
+            'DataFileExtension': 'pdf',
+            'DataFilePurpose': 'documentation',
+            'DataFileSize': 2048,
+            'DataFileUrl': 'https://example.com/doc.pdf'
+        }
+        
+        result = FileResponseMapper.map_to_file(data)
+        
+        self.assertIsInstance(result, File)
+        self.assertEqual(result.id, 'file-2')
+        self.assertEqual(result.name, 'document.pdf')
+        self.assertEqual(result.extension, 'pdf')
+        self.assertEqual(result.purpose, 'documentation')
+        self.assertEqual(result.size, 2048)
+        self.assertEqual(result.url, 'https://example.com/doc.pdf')
+
+    def test_map_to_file_mixed_keys(self):
+        data = {
+            'DataFileId': 'file-3',
+            'dataFileName': 'mixed.csv',
+            'DataFileExtension': 'csv',
+            'dataFilePurpose': 'data',
+            'DataFileSize': 512,
+            'dataFileUrl': 'https://example.com/data.csv'
+        }
+        
+        result = FileResponseMapper.map_to_file(data)
+        
+        self.assertEqual(result.id, 'file-3')
+        self.assertEqual(result.name, 'mixed.csv')
+        self.assertEqual(result.extension, 'csv')
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/core/files/test_models.py

@@ -0,0 +1,103 @@
+import unittest
+from unittest import TestCase
+
+from pygeai.core.files.models import BaseFile, UploadFile, File, FileList
+
+
+class TestFileResponses(TestCase):
+    """
+    python -m unittest pygeai.tests.core.files.test_models.TestFileResponses
+    """
+
+    def test_base_file_model_validate(self):
+        base_file_data = {
+            "id": "file123",
+            "name": "testfile.txt"
+        }
+        base_file = BaseFile.model_validate(base_file_data)
+        self.assertEqual(base_file.id, base_file_data["id"])
+        self.assertEqual(base_file.name, base_file_data["name"])
+        self.assertEqual(base_file.model_dump(), base_file_data)
+
+    def test_base_file_model_empty(self):
+        base_file_data = {}
+        base_file = BaseFile.model_validate(base_file_data)
+        self.assertIsNone(base_file.id)
+        self.assertIsNone(base_file.name)
+        self.assertEqual(base_file.model_dump(exclude_none=True), {})
+
+    def test_upload_file_model_validate(self):
+        upload_file_data = {
+            "id": "file123",
+            "name": "testfile.txt",
+            "path": "/uploads/testfile.txt",
+            "folder": "uploads"
+        }
+        upload_file = UploadFile.model_validate(upload_file_data)
+        self.assertEqual(upload_file.id, upload_file_data["id"])
+        self.assertEqual(upload_file.name, upload_file_data["name"])
+        self.assertEqual(upload_file.path, upload_file_data["path"])
+        self.assertEqual(upload_file.folder, upload_file_data["folder"])
+        self.assertEqual(upload_file.model_dump(), upload_file_data)
+
+    def test_upload_file_model_minimal(self):
+        upload_file_data = {
+            "path": "/uploads/testfile.txt"
+        }
+        upload_file = UploadFile.model_validate(upload_file_data)
+        self.assertIsNone(upload_file.id)
+        self.assertIsNone(upload_file.name)
+        self.assertEqual(upload_file.path, upload_file_data["path"])
+        self.assertIsNone(upload_file.folder)
+        self.assertEqual(upload_file.model_dump(exclude_none=True), upload_file_data)
+
+    def test_file_model_validate(self):
+        file_data = {
+            "id": "file123",
+            "name": "testfile.txt",
+            "extension": "txt",
+            "purpose": "test",
+            "size": 1024,
+            "url": "https://example.com/files/testfile.txt"
+        }
+        file_obj = File.model_validate(file_data)
+        self.assertEqual(file_obj.id, file_data["id"])
+        self.assertEqual(file_obj.name, file_data["name"])
+        self.assertEqual(file_obj.extension, file_data["extension"])
+        self.assertEqual(file_obj.purpose, file_data["purpose"])
+        self.assertEqual(file_obj.size, file_data["size"])
+        self.assertEqual(file_obj.url, file_data["url"])
+        self.assertEqual(file_obj.model_dump(), file_data)
+
+    def test_file_model_empty(self):
+        file_data = {}
+        file_obj = File.model_validate(file_data)
+        self.assertIsNone(file_obj.id)
+        self.assertIsNone(file_obj.name)
+        self.assertIsNone(file_obj.extension)
+        self.assertIsNone(file_obj.purpose)
+        self.assertEqual(file_obj.size, 0)
+        self.assertIsNone(file_obj.url)
+        self.assertEqual(file_obj.model_dump(exclude_none=True), {"size": 0})
+
+    def test_file_list_model_validate(self):
+        file_list_data = {
+            "files": [
+                {"id": "file1", "name": "file1.txt", "size": 512},
+                {"id": "file2", "name": "file2.pdf", "size": 2048, "url": "https://example.com/files/file2.pdf"}
+            ]
+        }
+        file_list = FileList.model_validate(file_list_data)
+        self.assertEqual(len(file_list.files), 2)
+        self.assertEqual(file_list.files[0].id, file_list_data["files"][0]["id"])
+        self.assertEqual(file_list.files[0].name, file_list_data["files"][0]["name"])
+        self.assertEqual(file_list.files[1].url, file_list_data["files"][1]["url"])
+        self.assertEqual(file_list.model_dump(exclude_none=True), file_list_data)
+
+    def test_file_list_model_empty(self):
+        file_list_data = {
+            "files": []
+        }
+        file_list = FileList.model_validate(file_list_data)
+        self.assertEqual(len(file_list.files), 0)
+        self.assertEqual(file_list.model_dump(exclude_none=True), file_list_data)