Add parameter validation to new my_account_api functions

Author: sam-muncke

src/auth0_server_python/auth_server/my_account_client.py

@@ -13,6 +13,8 @@
 )
 from auth0_server_python.error import (
     ApiError,
+    InvalidArgumentError,
+    MissingRequiredArgumentError,
     MyAccountApiError,
 )
 
@@ -104,6 +106,12 @@ async def list_connected_accounts(
         from_param: Optional[str] = None,
         take: Optional[int] = None
     ) -> ListConnectedAccountResponse:
+        if access_token is None:
+            raise MissingRequiredArgumentError("access_token")
+
+        if take is not None and (not isinstance(take, int) or take < 1):
+            raise InvalidArgumentError("take", "The 'take' parameter must be a positive integer.")
+
         try:
             async with httpx.AsyncClient() as client:
                 params = {}
@@ -149,6 +157,13 @@ async def delete_connected_account(
         access_token: str,
         connected_account_id: str
     ) -> None:
+
+        if access_token is None:
+            raise MissingRequiredArgumentError("access_token")
+
+        if connected_account_id is None:
+            raise MissingRequiredArgumentError("connected_account_id")
+
         try:
             async with httpx.AsyncClient() as client:
                 response = await client.delete(
@@ -181,6 +196,12 @@ async def list_connected_account_connections(
         from_param: Optional[str] = None,
         take: Optional[int] = None
     ) -> ListConnectedAccountConnectionsResponse:
+        if access_token is None:
+            raise MissingRequiredArgumentError("access_token")
+
+        if take is not None and (not isinstance(take, int) or take < 1):
+            raise InvalidArgumentError("take", "The 'take' parameter must be a positive integer.")
+
         try:
             async with httpx.AsyncClient() as client:
                 params = {}

src/auth0_server_python/auth_server/server_client.py

@@ -1500,7 +1500,7 @@ async def list_connected_accounts(
         """
         if take is not None and (not isinstance(take, int) or take < 1):
             raise InvalidArgumentError("take", "The 'take' parameter must be a positive integer.")
-        
+
         access_token = await self.get_access_token(
             audience=self._my_account_client.audience,
             scope="read:me:connected_accounts",
@@ -1527,7 +1527,7 @@ async def delete_connected_account(
         """
         if not connected_account_id:
             raise MissingRequiredArgumentError("connected_account_id")
-        
+
         access_token = await self.get_access_token(
             audience=self._my_account_client.audience,
             scope="delete:me:connected_accounts",
@@ -1559,7 +1559,7 @@ async def list_connected_account_connections(
         """
         if take is not None and (not isinstance(take, int) or take < 1):
             raise InvalidArgumentError("take", "The 'take' parameter must be a positive integer.")
-        
+
         access_token = await self.get_access_token(
             audience=self._my_account_client.audience,
             scope="read:me:connected_accounts",

src/auth0_server_python/error/__init__.py

@@ -108,7 +108,6 @@ class InvalidArgumentError(Auth0Error):
     code = "invalid_argument"
 
     def __init__(self, argument: str, message: str):
-        message = message
         super().__init__(message)
         self.name = "InvalidArgumentError"
         self.argument = argument

src/auth0_server_python/tests/test_my_account_client.py

@@ -13,7 +13,11 @@
     ListConnectedAccountConnectionsResponse,
     ListConnectedAccountResponse,
 )
-from auth0_server_python.error import MyAccountApiError
+from auth0_server_python.error import (
+    InvalidArgumentError,
+    MissingRequiredArgumentError,
+    MyAccountApiError,
+)
 
 
 @pytest.mark.asyncio
@@ -228,6 +232,45 @@ async def test_list_connected_accounts_success(mocker):
         next="<next_token>"
     )
 
+@pytest.mark.asyncio
+async def test_list_connected_accounts_missing_access_token(mocker):
+    # Arrange
+    client = MyAccountClient(domain="auth0.local")
+    mock_get = mocker.patch("httpx.AsyncClient.get", new_callable=AsyncMock)
+
+    # Act
+    with pytest.raises(MissingRequiredArgumentError) as exc:
+        await client.list_connected_accounts(
+        access_token=None,
+        connection="<connection>",
+        from_param="<from_param>",
+        take=2
+    )
+
+    # Assert
+    mock_get.assert_not_awaited()
+    assert "access_token" in str(exc.value)
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("take", ["not_an_integer", 21.3, -5, 0])
+async def test_list_connected_accounts_invalid_take_param(mocker, take):
+    # Arrange
+    client = MyAccountClient(domain="auth0.local")
+    mock_get = mocker.patch("httpx.AsyncClient.get", new_callable=AsyncMock)
+
+    # Act
+    with pytest.raises(InvalidArgumentError) as exc:
+        await client.list_connected_accounts(
+        access_token="<access_token>",
+        connection="<connection>",
+        from_param="<from_param>",
+        take=take
+    )
+
+    # Assert
+    mock_get.assert_not_awaited()
+    assert "The 'take' parameter must be a positive integer." in str(exc.value)
+
 @pytest.mark.asyncio
 async def test_list_connected_accounts_api_response_failure(mocker):
     # Arrange
@@ -277,6 +320,40 @@ async def test_delete_connected_account_success(mocker):
         auth=ANY
     )
 
+@pytest.mark.asyncio
+async def test_delete_connected_account_missing_access_token(mocker):
+    # Arrange
+    client = MyAccountClient(domain="auth0.local")
+    mock_delete = mocker.patch("httpx.AsyncClient.delete", new_callable=AsyncMock)
+
+    # Act
+    with pytest.raises(MissingRequiredArgumentError) as exc:
+        await client.delete_connected_account(
+            access_token=None,
+            connected_account_id="<id_1>"
+        )
+
+    # Assert
+    mock_delete.assert_not_awaited()
+    assert "access_token" in str(exc.value)
+
+@pytest.mark.asyncio
+async def test_delete_connected_account_missing_connected_account_id(mocker):
+    # Arrange
+    client = MyAccountClient(domain="auth0.local")
+    mock_delete = mocker.patch("httpx.AsyncClient.delete", new_callable=AsyncMock)
+
+    # Act
+    with pytest.raises(MissingRequiredArgumentError) as exc:
+        await client.delete_connected_account(
+            access_token="<access_token>",
+            connected_account_id=None
+        )
+
+    # Assert
+    mock_delete.assert_not_awaited()
+    assert "connected_account_id" in str(exc.value)
+
 @pytest.mark.asyncio
 async def test_delete_connected_account_api_response_failure(mocker):
     # Arrange
@@ -359,6 +436,44 @@ async def test_list_connected_account_connections_success(mocker):
         next="<next_token>"
     )
 
+@pytest.mark.asyncio
+async def test_list_connected_account_connections_missing_access_token(mocker):
+    # Arrange
+    client = MyAccountClient(domain="auth0.local")
+    mock_get = mocker.patch("httpx.AsyncClient.get", new_callable=AsyncMock)
+
+    # Act
+    with pytest.raises(MissingRequiredArgumentError) as exc:
+        await client.list_connected_account_connections(
+        access_token=None,
+        from_param="<from_param>",
+        take=2
+    )
+
+    # Assert
+    mock_get.assert_not_awaited()
+    assert "access_token" in str(exc.value)
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("take", ["not_an_integer", 21.3, -5, 0])
+async def test_list_connected_account_connections_invalid_take_param(mocker, take):
+    # Arrange
+    client = MyAccountClient(domain="auth0.local")
+    mock_get = mocker.patch("httpx.AsyncClient.get", new_callable=AsyncMock)
+
+    # Act
+    with pytest.raises(InvalidArgumentError) as exc:
+        await client.list_connected_account_connections(
+        access_token="<access_token>",
+        from_param="<from_param>",
+        take=take
+    )
+
+    # Assert
+    mock_get.assert_not_awaited()
+    assert "The 'take' parameter must be a positive integer." in str(exc.value)
+
+
 @pytest.mark.asyncio
 async def test_list_connected_account_connections_api_response_failure(mocker):
     # Arrange