pygeai 0.6.0b6__py3-none-any.whl → 0.6.0b10__py3-none-any.whl

pygeai/tests/migration/test_tools.py

@@ -1,7 +1,7 @@
 import unittest
 from unittest.mock import Mock
 
-from pygeai.migration.tools import MigrationTool
+from pygeai.migration.tools import MigrationTool, MigrationPlan, MigrationOrchestrator
 from pygeai.migration.strategies import MigrationStrategy
 
 
@@ -11,25 +11,149 @@ class TestMigrationTool(unittest.TestCase):
     """
 
     def setUp(self):
-        """Set up test fixtures"""
         self.mock_strategy = Mock(spec=MigrationStrategy)
 
     def test_migration_tool_initialization(self):
-        """Test MigrationTool initialization with a strategy"""
         tool = MigrationTool(self.mock_strategy)
-        self.assertEqual(tool.strategy, self.mock_strategy)
+        self.assertEqual(tool._strategy, self.mock_strategy)
 
     def test_migration_tool_set_strategy(self):
-        """Test setting a new strategy on MigrationTool"""
         tool = MigrationTool(self.mock_strategy)
         new_strategy = Mock(spec=MigrationStrategy)
         tool.set_strategy(new_strategy)
-
-        self.assertEqual(tool.strategy, new_strategy)
+        self.assertEqual(tool._strategy, new_strategy)
 
     def test_migration_tool_run_migration(self):
-        """Test running migration with the strategy"""
         tool = MigrationTool(self.mock_strategy)
         tool.run_migration()
+        self.mock_strategy.migrate.assert_called_once()
+
+
+class TestMigrationPlan(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.migration.test_tools.TestMigrationPlan
+    """
+
+    def test_migration_plan_initialization(self):
+        strategies = [Mock(spec=MigrationStrategy), Mock(spec=MigrationStrategy)]
+        plan = MigrationPlan(strategies=strategies)
+        self.assertEqual(len(plan.strategies), 2)
+        self.assertEqual(plan.dependencies, {})
+        self.assertFalse(plan.dry_run)
+        self.assertTrue(plan.stop_on_error)
+
+    def test_migration_plan_with_dependencies(self):
+        strategies = [Mock(spec=MigrationStrategy), Mock(spec=MigrationStrategy)]
+        dependencies = {1: [0]}
+        plan = MigrationPlan(strategies=strategies, dependencies=dependencies)
+        self.assertEqual(plan.dependencies, {1: [0]})
+
+
+class TestMigrationOrchestrator(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.migration.test_tools.TestMigrationOrchestrator
+    """
+
+    def setUp(self):
+        self.strategy1 = Mock(spec=MigrationStrategy)
+        self.strategy2 = Mock(spec=MigrationStrategy)
+        self.strategy3 = Mock(spec=MigrationStrategy)
+
+    def test_orchestrator_simple_execution(self):
+        plan = MigrationPlan(strategies=[self.strategy1, self.strategy2])
+        orchestrator = MigrationOrchestrator(plan)
+        
+        result = orchestrator.execute()
+        
+        self.strategy1.migrate.assert_called_once()
+        self.strategy2.migrate.assert_called_once()
+        self.assertEqual(result['total'], 2)
+        self.assertEqual(result['completed'], 2)
+        self.assertEqual(result['failed'], 0)
+        self.assertEqual(result['success_rate'], 1.0)
+
+    def test_orchestrator_with_dependencies(self):
+        plan = MigrationPlan(
+            strategies=[self.strategy1, self.strategy2, self.strategy3],
+            dependencies={1: [0], 2: [1]}
+        )
+        orchestrator = MigrationOrchestrator(plan)
+        
+        result = orchestrator.execute()
+        
+        self.assertEqual(result['completed'], 3)
+        self.assertEqual(result['completed_indices'], [0, 1, 2])
+
+    def test_orchestrator_stop_on_error(self):
+        self.strategy1.migrate.side_effect = Exception("Migration failed")
+        plan = MigrationPlan(
+            strategies=[self.strategy1, self.strategy2],
+            stop_on_error=True
+        )
+        orchestrator = MigrationOrchestrator(plan)
+        
+        with self.assertRaises(ValueError) as context:
+            orchestrator.execute()
+        
+        self.assertIn("Migration failed at strategy", str(context.exception))
+        self.strategy1.migrate.assert_called_once()
+        self.strategy2.migrate.assert_not_called()
+
+    def test_orchestrator_continue_on_error(self):
+        self.strategy1.migrate.side_effect = Exception("Migration failed")
+        plan = MigrationPlan(
+            strategies=[self.strategy1, self.strategy2],
+            stop_on_error=False
+        )
+        orchestrator = MigrationOrchestrator(plan)
+        
+        result = orchestrator.execute()
+        
+        self.strategy1.migrate.assert_called_once()
+        self.strategy2.migrate.assert_called_once()
+        self.assertEqual(result['completed'], 1)
+        self.assertEqual(result['failed'], 1)
+        self.assertEqual(result['success_rate'], 0.5)
+
+    def test_orchestrator_dry_run(self):
+        plan = MigrationPlan(
+            strategies=[self.strategy1, self.strategy2],
+            dry_run=True
+        )
+        orchestrator = MigrationOrchestrator(plan)
+        
+        result = orchestrator.execute()
+        
+        self.strategy1.migrate.assert_not_called()
+        self.strategy2.migrate.assert_not_called()
+        self.assertTrue(result['valid'])
+        self.assertEqual(result['execution_order'], [0, 1])
+
+    def test_orchestrator_circular_dependency(self):
+        plan = MigrationPlan(
+            strategies=[self.strategy1, self.strategy2],
+            dependencies={0: [1], 1: [0]}
+        )
+        orchestrator = MigrationOrchestrator(plan)
+        
+        with self.assertRaises(ValueError) as context:
+            orchestrator.execute()
+        
+        self.assertIn("Circular dependency", str(context.exception))
+
+    def test_orchestrator_dry_run_circular_dependency(self):
+        plan = MigrationPlan(
+            strategies=[self.strategy1, self.strategy2],
+            dependencies={0: [1], 1: [0]},
+            dry_run=True
+        )
+        orchestrator = MigrationOrchestrator(plan)
+        
+        result = orchestrator.execute()
+        
+        self.assertFalse(result['valid'])
+        self.assertIn("Circular dependency", result['error'])
+
 
-        self.mock_strategy.migrate.assert_called_once()
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/organization/limits/test_clients.py

@@ -47,6 +47,7 @@ class TestUsageLimitClient(unittest.TestCase):
     def test_set_organization_usage_limit_success(self, mock_post):
         mock_response = mock_post.return_value
         mock_response.json.return_value = self.valid_response
+        mock_response.status_code = 200
 
         result = self.client.set_organization_usage_limit(self.organization, self.valid_usage_limit)
 
@@ -79,6 +80,7 @@ class TestUsageLimitClient(unittest.TestCase):
         invalid_usage_limit["renewalStatus"] = "InvalidStatus"
         mock_response = mock_post.return_value
         mock_response.json.return_value = {"error": "Invalid renewal status"}
+        mock_response.status_code = 200
 
         result = self.client.set_organization_usage_limit(self.organization, invalid_usage_limit)
 
@@ -94,6 +96,7 @@ class TestUsageLimitClient(unittest.TestCase):
     def test_get_organization_latest_usage_limit_success(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.json.return_value = self.valid_response
+        mock_response.status_code = 200
 
         result = self.client.get_organization_latest_usage_limit(self.organization)
 
@@ -123,6 +126,7 @@ class TestUsageLimitClient(unittest.TestCase):
         response = {"limits": [self.valid_response]}
         mock_response = mock_get.return_value
         mock_response.json.return_value = response
+        mock_response.status_code = 200
 
         result = self.client.get_all_usage_limits_from_organization(self.organization)
 
@@ -153,6 +157,7 @@ class TestUsageLimitClient(unittest.TestCase):
         response = {"status": "deleted"}
         mock_response = mock_delete.return_value
         mock_response.json.return_value = response
+        mock_response.status_code = 200
 
         result = self.client.delete_usage_limit_from_organization(self.organization, self.limit_id)
 
@@ -183,6 +188,7 @@ class TestUsageLimitClient(unittest.TestCase):
         response["hardLimit"] = hard_limit
         mock_response = mock_put.return_value
         mock_response.json.return_value = response
+        mock_response.status_code = 200
 
         result = self.client.set_organization_hard_limit(self.organization, self.limit_id, hard_limit)
 
@@ -217,6 +223,7 @@ class TestUsageLimitClient(unittest.TestCase):
         response["softLimit"] = soft_limit
         mock_response = mock_put.return_value
         mock_response.json.return_value = response
+        mock_response.status_code = 200
 
         result = self.client.set_organization_soft_limit(self.organization, self.limit_id, soft_limit)
 
@@ -251,6 +258,7 @@ class TestUsageLimitClient(unittest.TestCase):
         response["renewalStatus"] = renewal_status
         mock_response = mock_put.return_value
         mock_response.json.return_value = response
+        mock_response.status_code = 200
 
         result = self.client.set_organization_renewal_status(self.organization, self.limit_id, renewal_status)
 
@@ -282,6 +290,7 @@ class TestUsageLimitClient(unittest.TestCase):
     def test_set_project_usage_limit_success(self, mock_post):
         mock_response = mock_post.return_value
         mock_response.json.return_value = self.valid_response
+        mock_response.status_code = 200
 
         result = self.client.set_project_usage_limit(self.organization, self.project, self.valid_usage_limit)
 
@@ -314,6 +323,7 @@ class TestUsageLimitClient(unittest.TestCase):
         invalid_usage_limit["subscriptionType"] = "InvalidType"
         mock_response = mock_post.return_value
         mock_response.json.return_value = {"error": "Invalid subscription type"}
+        mock_response.status_code = 200
 
         result = self.client.set_project_usage_limit(self.organization, self.project, invalid_usage_limit)
 
@@ -330,6 +340,7 @@ class TestUsageLimitClient(unittest.TestCase):
         response = {"limits": [self.valid_response]}
         mock_response = mock_get.return_value
         mock_response.json.return_value = response
+        mock_response.status_code = 200
 
         result = self.client.get_all_usage_limits_from_project(self.organization, self.project)
 
@@ -359,6 +370,7 @@ class TestUsageLimitClient(unittest.TestCase):
     def test_get_latest_usage_limit_from_project_success(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.json.return_value = self.valid_response
+        mock_response.status_code = 200
 
         result = self.client.get_latest_usage_limit_from_project(self.organization, self.project)
 
@@ -387,6 +399,7 @@ class TestUsageLimitClient(unittest.TestCase):
     def test_get_active_usage_limit_from_project_success(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.json.return_value = self.valid_response
+        mock_response.status_code = 200
 
         result = self.client.get_active_usage_limit_from_project(self.organization, self.project)
 
@@ -416,6 +429,7 @@ class TestUsageLimitClient(unittest.TestCase):
         response = {"status": "deleted"}
         mock_response = mock_delete.return_value
         mock_response.json.return_value = response
+        mock_response.status_code = 200
 
         result = self.client.delete_usage_limit_from_project(self.organization, self.project, self.limit_id)
 
@@ -446,6 +460,7 @@ class TestUsageLimitClient(unittest.TestCase):
         response["hardLimit"] = hard_limit
         mock_response = mock_put.return_value
         mock_response.json.return_value = response
+        mock_response.status_code = 200
 
         result = self.client.set_hard_limit_for_active_usage_limit_from_project(
             self.organization, self.project, self.limit_id, hard_limit
@@ -484,6 +499,7 @@ class TestUsageLimitClient(unittest.TestCase):
         response["softLimit"] = soft_limit
         mock_response = mock_put.return_value
         mock_response.json.return_value = response
+        mock_response.status_code = 200
 
         result = self.client.set_soft_limit_for_active_usage_limit_from_project(
             self.organization, self.project, self.limit_id, soft_limit
@@ -522,6 +538,7 @@ class TestUsageLimitClient(unittest.TestCase):
         response["renewalStatus"] = renewal_status
         mock_response = mock_put.return_value
         mock_response.json.return_value = response
+        mock_response.status_code = 200
 
         result = self.client.set_project_renewal_status(self.organization, self.project, self.limit_id, renewal_status)
 

pygeai/tests/organization/test_clients.py

@@ -5,7 +5,8 @@ from unittest.mock import patch
 from pygeai.organization.clients import OrganizationClient
 from pygeai.core.common.exceptions import InvalidAPIResponseException
 from pygeai.organization.endpoints import GET_ASSISTANT_LIST_V1, GET_PROJECT_LIST_V1, GET_PROJECT_V1, CREATE_PROJECT_V1, \
-    UPDATE_PROJECT_V1, DELETE_PROJECT_V1, GET_PROJECT_TOKENS_V1, GET_REQUEST_DATA_V1
+    UPDATE_PROJECT_V1, DELETE_PROJECT_V1, GET_PROJECT_TOKENS_V1, GET_REQUEST_DATA_V1, GET_MEMBERSHIPS_V2, \
+    GET_PROJECT_MEMBERSHIPS_V2, GET_PROJECT_ROLES_V2, GET_PROJECT_MEMBERS_V2, GET_ORGANIZATION_MEMBERS_V2
 
 
 class TestOrganizationClient(unittest.TestCase):
@@ -20,6 +21,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_get_assistant_list_success(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.json.return_value = {"assistants": [{"name": "assistant1"}, {"name": "assistant2"}]}
+        mock_response.status_code = 200
 
         result = self.client.get_assistant_list(detail="summary")
 
@@ -46,6 +48,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_get_project_list_success(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.json.return_value = {"projects": [{"name": "project1"}, {"name": "project2"}]}
+        mock_response.status_code = 200
 
         result = self.client.get_project_list(detail="summary")
 
@@ -59,6 +62,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_get_project_list_with_name(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.json.return_value = {"projects": [{"name": "specific_project"}]}
+        mock_response.status_code = 200
 
         result = self.client.get_project_list(detail="full", name="specific_project")
 
@@ -87,6 +91,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_get_project_data_success(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.json.return_value = {"project": {"id": "123", "name": "project1"}}
+        mock_response.status_code = 200
 
         result = self.client.get_project_data(project_id="123")
 
@@ -111,6 +116,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_create_project_success(self, mock_post):
         mock_response = mock_post.return_value
         mock_response.json.return_value = {"project": {"id": "123", "name": "project1"}}
+        mock_response.status_code = 200
 
         result = self.client.create_project(name="project1", email="admin@example.com", description="A test project")
 
@@ -129,6 +135,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_create_project_with_usage_limit(self, mock_post):
         mock_response = mock_post.return_value
         mock_response.json.return_value = {"project": {"id": "123", "name": "project1"}}
+        mock_response.status_code = 200
 
         usage_limit = {"type": "Requests", "threshold": 1000}
         result = self.client.create_project(
@@ -171,6 +178,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_update_project_success(self, mock_put):
         mock_response = mock_put.return_value
         mock_response.json.return_value = {"project": {"id": "123", "name": "updated_project"}}
+        mock_response.status_code = 200
 
         result = self.client.update_project(project_id="123", name="updated_project", description="Updated description")
 
@@ -201,6 +209,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_delete_project_success(self, mock_delete):
         mock_response = mock_delete.return_value
         mock_response.json.return_value = {"status": "deleted"}
+        mock_response.status_code = 200
 
         result = self.client.delete_project(project_id="123")
 
@@ -225,6 +234,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_get_project_tokens_success(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.json.return_value = {"tokens": ["token1", "token2"]}
+        mock_response.status_code = 200
 
         result = self.client.get_project_tokens(project_id="123")
 
@@ -251,6 +261,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_export_request_data_success(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.json.return_value = {"requests": [{"id": "1", "status": "pending"}]}
+        mock_response.status_code = 200
 
         result = self.client.export_request_data()
 
@@ -266,6 +277,7 @@ class TestOrganizationClient(unittest.TestCase):
     def test_export_request_data_with_params(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.json.return_value = {"requests": [{"id": "1", "status": "completed"}]}
+        mock_response.status_code = 200
 
         result = self.client.export_request_data(assistant_name="assistant1", status="completed", skip=10, count=5)
 
@@ -293,3 +305,196 @@ class TestOrganizationClient(unittest.TestCase):
         )
         self.assertEqual(str(context.exception), "Unable to export request data: Invalid JSON response")
 
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_memberships_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+        
+            "count": 1,
+            "pages": 1,
+            "organizationsMemberships": [
+                {
+                    "organizationId": "org-123",
+                    "organizationName": "Test Org",
+                    "projectsMemberships": []
+                }
+            ]
+        }
+        mock_response.status_code = 200
+
+        result = self.client.get_memberships()
+
+        mock_get.assert_called_once_with(
+            endpoint=GET_MEMBERSHIPS_V2,
+            params={"startPage": 1, "pageSize": 20, "orderDirection": "desc"}
+        )
+        self.assertIsNotNone(result)
+        self.assertEqual(result['count'], 1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_memberships_with_params(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {"count": 0, "pages": 0, "organizationsMemberships": []}
+        mock_response.status_code = 200
+
+        result = self.client.get_memberships(
+            email="test@example.com",
+            start_page=2,
+            page_size=10,
+            order_key="organizationName",
+            order_direction="asc",
+            role_types="backend,frontend"
+        )
+
+        mock_get.assert_called_once_with(
+            endpoint=GET_MEMBERSHIPS_V2,
+            params={
+                "email": "test@example.com",
+                "startPage": 2,
+                "pageSize": 10,
+                "orderKey": "organizationName",
+                "orderDirection": "asc",
+                "roleTypes": "backend,frontend"
+            }
+        )
+        self.assertIsNotNone(result)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_memberships_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_memberships()
+
+        self.assertEqual(str(context.exception), "Unable to get memberships: Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_memberships_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+        
+            "count": 1,
+            "pages": 1,
+            "projectsMemberships": [
+                {
+                    "organizationId": "org-123",
+                    "organizationName": "Test Org",
+                    "projectId": "proj-456",
+                    "projectName": "Test Project",
+                    "roles": []
+                }
+            ]
+        }
+        mock_response.status_code = 200
+
+        result = self.client.get_project_memberships()
+
+        mock_get.assert_called_once_with(
+            endpoint=GET_PROJECT_MEMBERSHIPS_V2,
+            params={"startPage": 1, "pageSize": 20, "orderDirection": "desc"}
+        )
+        self.assertIsNotNone(result)
+        self.assertEqual(result['count'], 1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_memberships_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_project_memberships()
+
+        self.assertEqual(str(context.exception), "Unable to get project memberships: Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_roles_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+        
+            "roles": [
+                {"id": "role-1", "name": "Admin", "externalId": "admin-ext", "type": "backend", "origin": "system"}
+            ]
+        }
+        mock_response.status_code = 200
+
+        result = self.client.get_project_roles(project_id="proj-123")
+
+        mock_get.assert_called_once_with(endpoint=GET_PROJECT_ROLES_V2, params={"projectId": "proj-123"})
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result['roles']), 1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_roles_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_project_roles(project_id="proj-123")
+
+        self.assertEqual(str(context.exception), "Unable to get project roles for project 'proj-123': Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_members_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+        
+            "members": [
+                {"email": "user@example.com", "roles": []}
+            ]
+        }
+        mock_response.status_code = 200
+
+        result = self.client.get_project_members(project_id="proj-123")
+
+        mock_get.assert_called_once_with(endpoint=GET_PROJECT_MEMBERS_V2, params={"projectId": "proj-123"})
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result['members']), 1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_project_members_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_project_members(project_id="proj-123")
+
+        self.assertEqual(str(context.exception), "Unable to get project members for project 'proj-123': Invalid JSON response")
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_organization_members_success(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = {
+        
+            "members": [
+                {"email": "user@example.com", "roles": []}
+            ]
+        }
+        mock_response.status_code = 200
+
+        result = self.client.get_organization_members(organization_id="org-123")
+
+        mock_get.assert_called_once_with(endpoint=GET_ORGANIZATION_MEMBERS_V2, params={"organizationId": "org-123"})
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result['members']), 1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_get_organization_members_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_organization_members(organization_id="org-123")
+
+        self.assertEqual(str(context.exception), "Unable to get organization members for organization 'org-123': Invalid JSON response")
+