Add user_invites change approve function users.py --> user_invites.py

shuvypermit · shuvypermit · commit c78ed5e16de8 · 2025-09-10T22:22:23.000+03:00
diff --git a/permit/api/api_client.py b/permit/api/api_client.py
@@ -15,6 +15,7 @@
 from .role_assignments import RoleAssignmentsApi
 from .roles import RolesApi
 from .tenants import TenantsApi
+from .user_invites import UserInvitesApi
 from .users import UsersApi
 
 
@@ -43,6 +44,7 @@ def __init__(self, config: PermitConfig):
         self._relationship_tuples = RelationshipTuplesApi(config)
         self._roles = RolesApi(config)
         self._tenants = TenantsApi(config)
+        self._user_invites = UserInvitesApi(config)
         self._users = UsersApi(config)
 
     @property
@@ -165,6 +167,14 @@ def tenants(self) -> TenantsApi:
         """
         return self._tenants
 
+    @property
+    def user_invites(self) -> UserInvitesApi:
+        """
+        API for managing user invites.
+        See: https://api.permit.io/v2/redoc#tag/User-Invites
+        """
+        return self._user_invites
+
     @property
     def users(self) -> UsersApi:
         """
diff --git a/permit/api/user_invites.py b/permit/api/user_invites.py
@@ -0,0 +1,51 @@
+from typing import List, Optional, Union
+
+from ..utils.pydantic_version import PYDANTIC_VERSION
+
+if PYDANTIC_VERSION < (2, 0):
+    from pydantic import validate_arguments
+else:
+    from pydantic.v1 import validate_arguments
+
+from .base import (
+    BasePermitApi,
+    SimpleHttpClient,
+    pagination_params,
+)
+from .context import ApiContextLevel, ApiKeyAccessLevel
+from .models import (
+    ElementsUserInviteApprove,
+    ElementsUserInviteRead,
+)
+
+
+class UserInvitesApi(BasePermitApi):
+    @property
+    def __user_invites(self) -> SimpleHttpClient:
+        return self._build_http_client(
+            f"/v2/facts/{self.config.api_context.project}/{self.config.api_context.environment}/user_invites"
+        )
+
+    @validate_arguments  # type: ignore[operator]
+    async def approve(self, user_invite_id: str, approve_data: ElementsUserInviteApprove) -> ElementsUserInviteRead:
+        """
+        Approves a user invite.
+
+        Args:
+            user_invite_id: The ID of the user invite to approve.
+            approve_data: The approval data for the user invite.
+
+        Returns:
+            the approved user invite.
+
+        Raises:
+            PermitApiError: If the API returns an error HTTP status code.
+            PermitContextError: If the configured ApiContext does not match the required endpoint context.
+        """
+        await self._ensure_access_level(ApiKeyAccessLevel.ENVIRONMENT_LEVEL_API_KEY)
+        await self._ensure_context(ApiContextLevel.ENVIRONMENT)
+        return await self.__user_invites.post(
+            f"/{user_invite_id}/approve",
+            model=ElementsUserInviteRead,
+            json=approve_data,
+        ) 
diff --git a/permit/api/users.py b/permit/api/users.py
@@ -14,8 +14,6 @@
 )
 from .context import ApiContextLevel, ApiKeyAccessLevel
 from .models import (
-    ElementsUserInviteApprove,
-    ElementsUserInviteRead,
     PaginatedResultUserRead,
     RoleAssignmentCreate,
     RoleAssignmentRead,
@@ -60,12 +58,6 @@ def __bulk_operations(self) -> SimpleHttpClient:
                 f"/v2/facts/{self.config.api_context.project}/{self.config.api_context.environment}/bulk/users"
             )
 
-    @property
-    def __user_invites(self) -> SimpleHttpClient:
-        return self._build_http_client(
-            f"/v2/facts/{self.config.api_context.project}/{self.config.api_context.environment}/user_invites"
-        )
-
     @validate_arguments  # type: ignore[operator]
     async def list(self, page: int = 1, per_page: int = 100) -> PaginatedResultUserRead:
         """
@@ -382,27 +374,3 @@ async def get_assigned_roles(
             model=List[RoleAssignmentRead],
             params=params,
         )
-
-    @validate_arguments  # type: ignore[operator]
-    async def approve(self, user_invite_id: str, approve_data: ElementsUserInviteApprove) -> ElementsUserInviteRead:
-        """
-        Approves a user invite.
-
-        Args:
-            user_invite_id: The ID of the user invite to approve.
-            approve_data: The approval data for the user invite.
-
-        Returns:
-            the approved user invite.
-
-        Raises:
-            PermitApiError: If the API returns an error HTTP status code.
-            PermitContextError: If the configured ApiContext does not match the required endpoint context.
-        """
-        await self._ensure_access_level(ApiKeyAccessLevel.ENVIRONMENT_LEVEL_API_KEY)
-        await self._ensure_context(ApiContextLevel.ENVIRONMENT)
-        return await self.__user_invites.post(
-            f"/{user_invite_id}/approve",
-            model=ElementsUserInviteRead,
-            json=approve_data,
-        )
diff --git a/tests/test_user_invite_approve_simple.py b/tests/test_user_invite_approve_simple.py
@@ -4,26 +4,28 @@
 """
 
 import uuid
+from unittest.mock import AsyncMock, patch
 
 import pytest
 
+from permit import Permit, PermitConfig
 from permit.api.models import ElementsUserInviteApprove, ElementsUserInviteRead, UserInviteStatus
-from permit.api.users import UsersApi
+from permit.api.user_invites import UserInvitesApi
 
 
 class TestUserInviteApproveSimple:
     """Simple test suite for user invite approve functionality."""
 
     def test_approve_method_exists(self):
-        """Test that the approve method exists in UsersApi."""
-        assert hasattr(UsersApi, "approve")
-        assert callable(UsersApi.approve)
+        """Test that the approve method exists in UserInvitesApi."""
+        assert hasattr(UserInvitesApi, "approve")
+        assert callable(UserInvitesApi.approve)
 
     def test_approve_method_signature(self):
         """Test that the approve method has the correct signature."""
         import inspect
 
-        method = UsersApi.approve
+        method = UserInvitesApi.approve
         signature = inspect.signature(method)
 
         # Check parameter names
@@ -57,8 +59,8 @@ def test_approve_data_model_key_validation(self):
         with pytest.raises(ValueError):
             ElementsUserInviteApprove(
                 email="test@example.com",
-                key="invalid key with spaces",  # Should fail regex validation
-                attributes={},
+                key="invalid key with spaces",
+                attributes={},  # Should fail regex validation
             )
 
     def test_approve_data_model_with_complex_attributes(self):
@@ -121,7 +123,7 @@ def test_approve_parameter_types(self):
         """Test that the approve method parameters have correct types."""
         from typing import get_type_hints
 
-        method = UsersApi.approve
+        method = UserInvitesApi.approve
         type_hints = get_type_hints(method)
 
         # Check parameter types
@@ -158,3 +160,131 @@ def test_approve_data_serialization(self):
         parsed_data = json.loads(json_str)
         assert parsed_data["email"] == "test@example.com"
         assert parsed_data["key"] == "test-key-123"
+
+    def test_permit_instance_has_user_invites_api(self):
+        """Test that Permit instance exposes user_invites API correctly."""
+        # Create a Permit instance with mock configuration
+        config = PermitConfig(token="test-token-123", api_url="http://localhost:8000", pdp="http://localhost:7766")
+        permit = Permit(config)
+
+        # Test that user_invites API is accessible
+        assert hasattr(permit.api, "user_invites")
+        assert permit.api.user_invites is not None
+
+        # Test that the approve method is available
+        assert hasattr(permit.api.user_invites, "approve")
+        assert callable(permit.api.user_invites.approve)
+
+    @pytest.mark.asyncio
+    async def test_permit_user_invites_approve_usage_pattern(self):
+        """
+        Test the actual usage pattern: permit.api.user_invites.approve()
+        This test mimics how users will actually use the function.
+        """
+        # Create a Permit instance with mock configuration
+        config = PermitConfig(token="test-token-123", api_url="http://localhost:8000", pdp="http://localhost:7766")
+        permit = Permit(config)
+
+        # Create test data - this is how users will use it
+        user_invite_id = "test-invite-uuid-123"
+        approve_data = ElementsUserInviteApprove(
+            email="newuser@company.com",
+            key="new-user-invite-key",
+            attributes={
+                "department": "Engineering",
+                "role": "Developer",
+                "start_date": "2024-01-15",
+                "manager": "manager@company.com",
+            },
+        )
+
+        # Mock the entire approve method to avoid HTTP calls
+        mock_response = ElementsUserInviteRead(
+            id=uuid.uuid4(),
+            organization_id=uuid.uuid4(),
+            project_id=uuid.uuid4(),
+            environment_id=uuid.uuid4(),
+            key="new-user-invite-key",
+            status=UserInviteStatus.approved,
+            email="newuser@company.com",
+            first_name="New",
+            last_name="User",
+            role_id=uuid.uuid4(),
+            tenant_id=uuid.uuid4(),
+            created_at="2024-01-01T00:00:00Z",
+            updated_at="2024-01-01T01:00:00Z",
+        )
+
+        # Mock just the approve method
+        with patch.object(permit.api.user_invites, "approve", new_callable=AsyncMock) as mock_approve:
+            mock_approve.return_value = mock_response
+
+            # This is the actual usage pattern that users will use!
+            result = await permit.api.user_invites.approve(user_invite_id, approve_data)
+
+            # Verify the result
+            assert isinstance(result, ElementsUserInviteRead)
+            assert result.status == UserInviteStatus.approved
+            assert result.email == "newuser@company.com"
+            assert result.key == "new-user-invite-key"
+
+            # Verify the method was called with correct parameters
+            mock_approve.assert_called_once_with(user_invite_id, approve_data)
+
+    def test_user_invites_api_integration_in_permit_client(self):
+        """Test that the UserInvitesApi is properly integrated into the Permit client."""
+        config = PermitConfig(token="test-token-123", api_url="http://localhost:8000", pdp="http://localhost:7766")
+        permit = Permit(config)
+
+        # Test the complete integration
+        assert hasattr(permit, "api")
+        assert hasattr(permit.api, "user_invites")
+        assert isinstance(permit.api.user_invites, UserInvitesApi)
+
+        # Test that it's different from users API
+        assert hasattr(permit.api, "users")
+        assert permit.api.user_invites is not permit.api.users
+        assert type(permit.api.user_invites).__name__ == "UserInvitesApi"
+        assert type(permit.api.users).__name__ == "UsersApi"
+
+    def test_actual_usage_pattern_structure(self):
+        """
+        Test that the actual usage pattern permit.api.user_invites.approve() is available.
+        This verifies the complete structure that users will interact with.
+        """
+        # Create a real Permit instance (no mocking)
+        config = PermitConfig(token="test-token-123", api_url="http://localhost:8000", pdp="http://localhost:7766")
+        permit = Permit(config)
+
+        # Create real test data as users would
+        approve_data = ElementsUserInviteApprove(
+            email="newuser@company.com",
+            key="new-user-invite-key",
+            attributes={"department": "Engineering", "role": "Developer", "start_date": "2024-01-15"},
+        )
+
+        # Verify the complete call chain exists (this is what users will use)
+        assert hasattr(permit, "api"), "permit.api should exist"
+        assert hasattr(permit.api, "user_invites"), "permit.api.user_invites should exist"
+        assert hasattr(permit.api.user_invites, "approve"), "permit.api.user_invites.approve should exist"
+        assert callable(permit.api.user_invites.approve), "permit.api.user_invites.approve should be callable"
+
+        # Verify the method signature matches what users expect
+        import inspect
+
+        method = permit.api.user_invites.approve
+        signature = inspect.signature(method)
+        params = list(signature.parameters.keys())
+
+        assert "user_invite_id" in params, "Method should accept user_invite_id parameter"
+        assert "approve_data" in params, "Method should accept approve_data parameter"
+
+        # Verify the approve_data can be created with user's data
+        assert approve_data.email == "newuser@company.com"
+        assert approve_data.key == "new-user-invite-key"
+        assert approve_data.attributes["department"] == "Engineering"
+
+
+if __name__ == "__main__":
+    # Run with: python -m pytest tests/test_user_invite_approve_simple.py -v
+    pass
