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

pygeai/tests/organization/test_managers.py

@@ -0,0 +1,424 @@
+import unittest
+from unittest.mock import patch
+
+from pygeai.core.base.mappers import ResponseMapper
+from pygeai.core.common.exceptions import APIError
+from pygeai.core.handlers import ErrorHandler
+from pygeai.core.models import Project
+from pygeai.core.base.responses import EmptyResponse
+from pygeai.organization.managers import OrganizationManager
+from pygeai.organization.mappers import OrganizationResponseMapper
+from pygeai.organization.responses import AssistantListResponse, ProjectListResponse, ProjectDataResponse, \
+    ProjectTokensResponse, ProjectItemListResponse, MembershipsResponse, ProjectMembershipsResponse, \
+    ProjectRolesResponse, ProjectMembersResponse, OrganizationMembersResponse
+
+
+class TestOrganizationManager(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.organization.test_managers.TestOrganizationManager
+    """
+
+    def setUp(self):
+        self.manager = OrganizationManager()
+        self.project = Project(
+            id="123",
+            name="Test Project",
+            description="Test Description",
+            email="test@example.com",
+            usage_limit=None
+        )
+        self.error_response = {"errors": [{"id": 404, "description": "Project not found"}]}
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_assistant_list")
+    def test_get_assistant_list(self, mock_get_assistant_list):
+        mock_response = AssistantListResponse(assistants=[])
+        mock_get_assistant_list.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_assistant_list_response', return_value=mock_response):
+            response = self.manager.get_assistant_list(detail="summary")
+
+        self.assertIsInstance(response, AssistantListResponse)
+        self.assertEqual(response.assistants, [])
+        mock_get_assistant_list.assert_called_once_with(detail="summary")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_assistant_list")
+    def test_get_assistant_list_error(self, mock_get_assistant_list):
+        mock_get_assistant_list.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_assistant_list(detail="summary")
+
+        self.assertIn("Error received while retrieving assistant list", str(context.exception))
+        mock_get_assistant_list.assert_called_once_with(detail="summary")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_list")
+    def test_get_project_list(self, mock_get_project_list):
+        mock_response = ProjectListResponse(projects=[])
+        mock_get_project_list.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_list_response', return_value=mock_response):
+            response = self.manager.get_project_list(detail="summary")
+
+        self.assertIsInstance(response, ProjectListResponse)
+        self.assertEqual(response.projects, [])
+        mock_get_project_list.assert_called_once_with(detail="summary", name=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_list")
+    def test_get_project_list_error(self, mock_get_project_list):
+        mock_get_project_list.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_list(detail="summary")
+
+        self.assertIn("Error received while retrieving project list", str(context.exception))
+        mock_get_project_list.assert_called_once_with(detail="summary", name=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_data")
+    def test_get_project_data(self, mock_get_project_data):
+        mock_response = ProjectDataResponse(project=self.project)
+        mock_get_project_data.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_data', return_value=mock_response):
+            response = self.manager.get_project_data("123")
+
+        self.assertIsInstance(response, ProjectDataResponse)
+        self.assertEqual(response.project.name, "Test Project")
+        mock_get_project_data.assert_called_once_with(project_id="123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_data")
+    def test_get_project_data_error_handling(self, mock_get_project_data):
+        mock_get_project_data.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_data("invalid_id")
+
+        self.assertIn("Error received while retrieving project data", str(context.exception))
+        mock_get_project_data.assert_called_once_with(project_id="invalid_id")
+
+    @patch("pygeai.organization.clients.OrganizationClient.create_project")
+    def test_create_project(self, mock_create_project):
+        mock_response = ProjectDataResponse(project=self.project)
+        mock_create_project.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_data', return_value=mock_response):
+            response = self.manager.create_project(self.project)
+
+        self.assertIsInstance(response, ProjectDataResponse)
+        self.assertEqual(response.project.name, "Test Project")
+        mock_create_project.assert_called_once_with(
+            name=self.project.name,
+            email=self.project.email,
+            description=self.project.description,
+            usage_limit=None
+        )
+
+    @patch("pygeai.organization.clients.OrganizationClient.create_project")
+    def test_create_project_error(self, mock_create_project):
+        mock_create_project.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project creation failed"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.create_project(self.project)
+
+        self.assertIn("Error received while creating project", str(context.exception))
+        mock_create_project.assert_called_once_with(
+            name=self.project.name,
+            email=self.project.email,
+            description=self.project.description,
+            usage_limit=None
+        )
+
+    @patch("pygeai.organization.clients.OrganizationClient.update_project")
+    def test_update_project(self, mock_update_project):
+        updated_project = Project(
+            id="123",
+            name="Updated Project",
+            description="An updated test project",
+            email="test@example.com",
+            usage_limit=None
+        )
+        mock_response = ProjectDataResponse(project=updated_project)
+        mock_update_project.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_data', return_value=mock_response):
+            response = self.manager.update_project(updated_project)
+
+        self.assertIsInstance(response, ProjectDataResponse)
+        self.assertEqual(response.project.name, "Updated Project")
+        mock_update_project.assert_called_once_with(
+            project_id=updated_project.id,
+            name=updated_project.name,
+            description=updated_project.description
+        )
+
+    @patch("pygeai.organization.clients.OrganizationClient.update_project")
+    def test_update_project_error(self, mock_update_project):
+        updated_project = Project(
+            id="123",
+            name="Updated Project",
+            description="An updated test project",
+            email="test@example.com",
+            usage_limit=None
+        )
+        mock_update_project.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Update failed"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.update_project(updated_project)
+
+        self.assertIn("Error received while updating project", str(context.exception))
+        mock_update_project.assert_called_once_with(
+            project_id=updated_project.id,
+            name=updated_project.name,
+            description=updated_project.description
+        )
+
+    @patch("pygeai.organization.clients.OrganizationClient.delete_project")
+    def test_delete_project(self, mock_delete_project):
+        mock_response = EmptyResponse(content={})
+        mock_delete_project.return_value = {}
+
+        with patch.object(ResponseMapper, 'map_to_empty_response', return_value=mock_response):
+            response = self.manager.delete_project("123")
+
+        self.assertIsInstance(response, EmptyResponse)
+        self.assertEqual(response.content, {})
+        mock_delete_project.assert_called_once_with(project_id="123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.delete_project")
+    def test_delete_project_error_handling(self, mock_delete_project):
+        mock_delete_project.return_value = {"errors": [{"id": 403, "description": "Permission denied"}]}
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Permission denied"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.delete_project("invalid_id")
+
+        self.assertIn("Error received while deleting project", str(context.exception))
+        mock_delete_project.assert_called_once_with(project_id="invalid_id")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_tokens")
+    def test_get_project_tokens(self, mock_get_project_tokens):
+        mock_response = ProjectTokensResponse(tokens=[])
+        mock_get_project_tokens.return_value = {"tokens": []}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_token_list_response', return_value=mock_response):
+            response = self.manager.get_project_tokens("123")
+
+        self.assertIsInstance(response, ProjectTokensResponse)
+        self.assertEqual(response.tokens, [])
+        mock_get_project_tokens.assert_called_once_with(project_id="123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_tokens")
+    def test_get_project_tokens_error(self, mock_get_project_tokens):
+        mock_get_project_tokens.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_tokens("invalid_id")
+
+        self.assertIn("Error received while retrieving project tokens", str(context.exception))
+        mock_get_project_tokens.assert_called_once_with(project_id="invalid_id")
+
+    @patch("pygeai.organization.clients.OrganizationClient.export_request_data")
+    def test_export_request_data(self, mock_export_request_data):
+        mock_response = ProjectItemListResponse(items=[])
+        mock_export_request_data.return_value = {"items": []}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_item_list_response', return_value=mock_response):
+            response = self.manager.export_request_data(assistant_name="assistant1", status="completed", skip=10, count=5)
+
+        self.assertIsInstance(response, ProjectItemListResponse)
+        self.assertEqual(response.items, [])
+        mock_export_request_data.assert_called_once_with(
+            assistant_name="assistant1",
+            status="completed",
+            skip=10,
+            count=5
+        )
+
+    @patch("pygeai.organization.clients.OrganizationClient.export_request_data")
+    def test_export_request_data_error(self, mock_export_request_data):
+        mock_export_request_data.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Export failed"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.export_request_data()
+
+        self.assertIn("Error received while exporting request data", str(context.exception))
+        mock_export_request_data.assert_called_once_with(
+            assistant_name=None,
+            status=None,
+            skip=0,
+            count=0
+        )
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_memberships")
+    def test_get_memberships(self, mock_get_memberships):
+        mock_response = MembershipsResponse(count=0, pages=0, organizations=[])
+        mock_get_memberships.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_memberships_response', return_value=mock_response):
+            response = self.manager.get_memberships()
+
+        self.assertIsInstance(response, MembershipsResponse)
+        self.assertEqual(response.count, 0)
+        mock_get_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_memberships")
+    def test_get_memberships_error(self, mock_get_memberships):
+        mock_get_memberships.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Access denied"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_memberships()
+
+        self.assertIn("Error received while retrieving memberships", str(context.exception))
+        mock_get_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_memberships")
+    def test_get_project_memberships(self, mock_get_project_memberships):
+        mock_response = ProjectMembershipsResponse(count=0, pages=0, projects=[])
+        mock_get_project_memberships.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_memberships_response', return_value=mock_response):
+            response = self.manager.get_project_memberships()
+
+        self.assertIsInstance(response, ProjectMembershipsResponse)
+        self.assertEqual(response.count, 0)
+        mock_get_project_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_memberships")
+    def test_get_project_memberships_error(self, mock_get_project_memberships):
+        mock_get_project_memberships.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Access denied"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_memberships()
+
+        self.assertIn("Error received while retrieving project memberships", str(context.exception))
+        mock_get_project_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_roles")
+    def test_get_project_roles(self, mock_get_project_roles):
+        mock_response = ProjectRolesResponse(roles=[])
+        mock_get_project_roles.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_roles_response', return_value=mock_response):
+            response = self.manager.get_project_roles("proj-123")
+
+        self.assertIsInstance(response, ProjectRolesResponse)
+        self.assertEqual(response.roles, [])
+        mock_get_project_roles.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_roles")
+    def test_get_project_roles_error(self, mock_get_project_roles):
+        mock_get_project_roles.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_roles("proj-123")
+
+        self.assertIn("Error received while retrieving project roles", str(context.exception))
+        mock_get_project_roles.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_members")
+    def test_get_project_members(self, mock_get_project_members):
+        mock_response = ProjectMembersResponse(members=[])
+        mock_get_project_members.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_members_response', return_value=mock_response):
+            response = self.manager.get_project_members("proj-123")
+
+        self.assertIsInstance(response, ProjectMembersResponse)
+        self.assertEqual(response.members, [])
+        mock_get_project_members.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_members")
+    def test_get_project_members_error(self, mock_get_project_members):
+        mock_get_project_members.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_members("proj-123")
+
+        self.assertIn("Error received while retrieving project members", str(context.exception))
+        mock_get_project_members.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_organization_members")
+    def test_get_organization_members(self, mock_get_organization_members):
+        mock_response = OrganizationMembersResponse(members=[])
+        mock_get_organization_members.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_organization_members_response', return_value=mock_response):
+            response = self.manager.get_organization_members("org-123")
+
+        self.assertIsInstance(response, OrganizationMembersResponse)
+        self.assertEqual(response.members, [])
+        mock_get_organization_members.assert_called_once_with(organization_id="org-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_organization_members")
+    def test_get_organization_members_error(self, mock_get_organization_members):
+        mock_get_organization_members.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Organization not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_organization_members("org-123")
+
+        self.assertIn("Error received while retrieving organization members", str(context.exception))
+        mock_get_organization_members.assert_called_once_with(organization_id="org-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.add_project_member")
+    def test_add_project_member(self, mock_add_project_member):
+        mock_response = EmptyResponse(content="Invitation sent successfully")
+        mock_add_project_member.return_value = {}
+
+        with patch.object(ResponseMapper, 'map_to_empty_response', return_value=mock_response):
+            response = self.manager.add_project_member(
+                project_id="proj-123",
+                user_email="newuser@example.com",
+                roles=["Project member"]
+            )
+
+        self.assertIsInstance(response, EmptyResponse)
+        self.assertEqual(response.content, "Invitation sent successfully")
+        mock_add_project_member.assert_called_once_with(
+            project_id="proj-123",
+            user_email="newuser@example.com",
+            roles=["Project member"]
+        )
+
+    @patch("pygeai.organization.clients.OrganizationClient.add_project_member")
+    def test_add_project_member_error(self, mock_add_project_member):
+        mock_add_project_member.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Invalid role"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.add_project_member(
+                        project_id="proj-123",
+                        user_email="newuser@example.com",
+                        roles=["Invalid role"]
+                    )
+
+        self.assertIn("Error received while adding project member", str(context.exception))
+        mock_add_project_member.assert_called_once_with(
+            project_id="proj-123",
+            user_email="newuser@example.com",
+            roles=["Invalid role"]
+        )

pygeai/tests/organization/test_mappers.py

@@ -0,0 +1,153 @@
+import unittest
+from unittest.mock import patch
+from pygeai.core.models import Assistant, Project, ProjectToken, RequestItem
+from pygeai.organization.responses import AssistantListResponse, ProjectListResponse, ProjectDataResponse, \
+    ProjectTokensResponse, ProjectItemListResponse
+from pygeai.organization.mappers import OrganizationResponseMapper
+
+
+class TestOrganizationResponseMapper(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.organization.test_mappers.TestOrganizationResponseMapper
+    """
+
+    def test_map_to_assistant_list_response_with_project_data(self):
+        data = {
+            "assistants": [{"assistantId": "1", "assistantName": "Assistant1"}],
+            "projectId": "proj1",
+            "projectName": "Project1"
+        }
+        expected_assistant = Assistant(
+            id="1",
+            name="Assistant1",
+            project=Project(id="proj1", name="Project1")
+        )
+
+        with patch('pygeai.core.base.mappers.ModelMapper.map_to_assistant', return_value=expected_assistant):
+            result = OrganizationResponseMapper.map_to_assistant_list_response(data)
+
+        self.assertIsInstance(result, AssistantListResponse)
+        self.assertEqual(len(result.assistants), 1)
+        self.assertEqual(result.assistants[0].id, "1")
+        self.assertEqual(result.assistants[0].project.id, "proj1")
+        self.assertEqual(result.assistants[0].project.name, "Project1")
+
+    def test_map_to_assistant_list_response_empty_assistants(self):
+        data = {"assistants": []}
+
+        result = OrganizationResponseMapper.map_to_assistant_list_response(data)
+
+        self.assertIsInstance(result, AssistantListResponse)
+        self.assertEqual(len(result.assistants), 0)
+
+    def test_map_to_assistant_list_with_valid_data(self):
+        data = {"assistants": [{"assistantId": "1", "assistantName": "Assistant1"}]}
+        expected_assistant = Assistant(id="1", name="Assistant1")
+
+        with patch('pygeai.core.base.mappers.ModelMapper.map_to_assistant', return_value=expected_assistant):
+            result = OrganizationResponseMapper.map_to_assistant_list(data)
+
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0].id, "1")
+        self.assertEqual(result[0].name, "Assistant1")
+
+    def test_map_to_assistant_list_with_empty_data(self):
+        data = {"assistants": []}
+
+        result = OrganizationResponseMapper.map_to_assistant_list(data)
+
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 0)
+
+    def test_map_to_project_list_response_with_valid_data(self):
+        data = {"projects": [{"projectId": "1", "projectName": "Project1"}]}
+        expected_project = Project(id="1", name="Project1")
+
+        with patch('pygeai.core.base.mappers.ModelMapper.map_to_project', return_value=expected_project):
+            result = OrganizationResponseMapper.map_to_project_list_response(data)
+
+        self.assertIsInstance(result, ProjectListResponse)
+        self.assertEqual(len(result.projects), 1)
+        self.assertEqual(result.projects[0].id, "1")
+        self.assertEqual(result.projects[0].name, "Project1")
+
+    def test_map_to_project_list_response_with_empty_data(self):
+        data = {"projects": []}
+
+        result = OrganizationResponseMapper.map_to_project_list_response(data)
+
+        self.assertIsInstance(result, ProjectListResponse)
+        self.assertEqual(len(result.projects), 0)
+
+    def test_map_to_project_list_with_valid_data(self):
+        data = {"projects": [{"projectId": "1", "projectName": "Project1"}]}
+        expected_project = Project(id="1", name="Project1")
+
+        with patch('pygeai.core.base.mappers.ModelMapper.map_to_project', return_value=expected_project):
+            result = OrganizationResponseMapper.map_to_project_list(data)
+
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0].id, "1")
+        self.assertEqual(result[0].name, "Project1")
+
+    def test_map_to_project_list_with_empty_data(self):
+        data = {"projects": []}
+
+        result = OrganizationResponseMapper.map_to_project_list(data)
+
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 0)
+
+    def test_map_to_project_data_with_valid_data(self):
+        data = {"projectId": "1", "projectName": "Project1"}
+        expected_project = Project(id="1", name="Project1")
+
+        with patch('pygeai.core.base.mappers.ModelMapper.map_to_project', return_value=expected_project):
+            result = OrganizationResponseMapper.map_to_project_data(data)
+
+        self.assertIsInstance(result, ProjectDataResponse)
+        self.assertEqual(result.project.id, "1")
+        self.assertEqual(result.project.name, "Project1")
+
+    def test_map_to_token_list_response_with_valid_data(self):
+        data = {"tokens": [{"id": "1", "name": "Token1", "status": "Active", "timestamp": "2023-01-01T00:00:00+00:00"}]}
+        expected_token = ProjectToken(
+            token_id="1",
+            name="Token1",
+            status="Active",
+            timestamp="2023-01-01T00:00:00+00:00"
+        )
+
+        with patch('pygeai.core.base.mappers.ModelMapper.map_to_token_list', return_value=[expected_token]):
+            result = OrganizationResponseMapper.map_to_token_list_response(data)
+
+        self.assertIsInstance(result, ProjectTokensResponse)
+        self.assertEqual(len(result.tokens), 1)
+        self.assertEqual(result.tokens[0].token_id, "1")
+        self.assertEqual(result.tokens[0].name, "Token1")
+
+    def test_map_to_item_list_response_with_valid_data(self):
+        data = {"items": [{"assistant": "Assistant1", "timestamp": "2023-01-01T00:00:00", "status": "succeeded"}]}
+        expected_item = RequestItem(
+            api_token="token123",
+            assistant="Assistant1",
+            cost=0.5,
+            elapsed_time_ms=1000,
+            end_timestamp="2023-01-01T00:01:00",
+            module="test_module",
+            session_id="session123",
+            start_timestamp="2023-01-01T00:00:00",
+            status="succeeded",
+            timestamp="2023-01-01T00:00:00"
+        )
+
+        with patch('pygeai.core.base.mappers.ModelMapper.map_to_item_list', return_value=[expected_item]):
+            result = OrganizationResponseMapper.map_to_item_list_response(data)
+
+        self.assertIsInstance(result, ProjectItemListResponse)
+        self.assertEqual(len(result.items), 1)
+        self.assertEqual(result.items[0].assistant, "Assistant1")
+        self.assertEqual(result.items[0].status, "succeeded")
+