Remove parameters from login method

maxachis · maxachis · commit ef92d1777992 · 2025-06-30T16:20:18.000-04:00
diff --git a/DEV.md b/DEV.md
@@ -1,3 +1,10 @@
+
+To bump the version, add a tag, and push, run 
+```bash
+python bump_version.py patch --tag --push
+```
+If bumping a minor or major version, replace `patch` with `minor` or `major`
+
 To bump the version by a patch, run:
 ```bash
 poetry version patch
diff --git a/manual_tests/test_manual_access_manager.py b/manual_tests/test_manual_access_manager.py
@@ -1,7 +1,7 @@
 from aiohttp import ClientSession
 from environs import Env
 
-from pdap_access_manager.access_manager import AccessManager
+from pdap_access_manager.src.access_manager import AccessManager
 from pdap_access_manager import RequestType, DataSourcesNamespaces, RequestInfo
 
 
diff --git a/pdap_access_manager/__init__.py b/pdap_access_manager/__init__.py
@@ -1,8 +0,0 @@
-from pdap_access_manager.access_manager import AccessManager
-from pdap_access_manager.request import RequestInfo
-from pdap_access_manager.response import ResponseInfo
-from pdap_access_manager.enums import RequestType, DataSourcesNamespaces, SourceCollectorNamespaces
-
-__all__ = [
-    "AccessManager"
-]
diff --git a/pdap_access_manager/src/__init__.py b/pdap_access_manager/src/__init__.py
diff --git a/pdap_access_manager/src/access_manager.py b/pdap_access_manager/src/access_manager.py
@@ -1,11 +1,13 @@
 from contextlib import asynccontextmanager
 from http import HTTPStatus
-from typing import Optional
+from typing import Optional, Any, AsyncGenerator
 
 from aiohttp import ClientSession, ClientResponseError
 
-from pdap_access_manager import RequestType, DataSourcesNamespaces, SourceCollectorNamespaces, ResponseInfo, RequestInfo
-from pdap_access_manager.constants import DEFAULT_DATA_SOURCES_URL, DEFAULT_SOURCE_COLLECTOR_URL
+from pdap_access_manager.src.constants import DEFAULT_DATA_SOURCES_URL, DEFAULT_SOURCE_COLLECTOR_URL
+from pdap_access_manager.src.enums import RequestType, DataSourcesNamespaces, SourceCollectorNamespaces
+from pdap_access_manager.src.models.request import RequestInfo
+from pdap_access_manager.src.models.response import ResponseInfo
 
 request_methods = {
     RequestType.POST: ClientSession.post,
@@ -45,7 +47,7 @@ def __init__(
         self.source_collector_url = source_collector_url
 
     @asynccontextmanager
-    async def with_session(self) -> "AccessManager":
+    async def with_session(self) -> AsyncGenerator["AccessManager", Any]:
         """Allows just the session lifecycle to be managed."""
         created_session = False
         if self.session is None:
@@ -102,10 +104,7 @@ async def access_token(self) -> str:
         :return:
         """
         if self._access_token is None:
-            await self.login(
-                email=self.email,
-                password=self.password
-            )
+            await self.login()
         return self._access_token
 
     @property
@@ -115,10 +114,7 @@ async def refresh_token(self) -> str:
         :return:
         """
         if self._refresh_token is None:
-            await self.login(
-                email=self.email,
-                password=self.password
-            )
+            await self.login()
         return self._refresh_token
 
     async def load_api_key(self):
@@ -159,7 +155,7 @@ async def refresh_access_token(self):
             self._refresh_token = data['refresh_token']
         except ClientResponseError as e:
             if e.status == HTTPStatus.UNAUTHORIZED:  # Token expired, retry logging in
-                await self.login(self.email, self.password)
+                await self.login()
 
     async def make_request(self, ri: RequestInfo, allow_retry: bool = True) -> ResponseInfo:
         """
@@ -187,11 +183,9 @@ async def make_request(self, ri: RequestInfo, allow_retry: bool = True) -> Respo
             raise e
 
 
-    async def login(self, email: str, password: str):
+    async def login(self) -> None:
         """
         Login to PDAP and retrieve access and refresh tokens
-        :param email:
-        :param password:
         :return:
         """
         url = self.build_url(
@@ -202,8 +196,8 @@ async def login(self, email: str, password: str):
             type_=RequestType.POST,
             url=url,
             json_={
-                "email": email,
-                "password": password
+                "email": self.email,
+                "password": self.password
             }
         )
         response_info = await self.make_request(request_info)
diff --git a/pdap_access_manager/src/constants.py b/pdap_access_manager/src/constants.py
diff --git a/pdap_access_manager/src/enums.py b/pdap_access_manager/src/enums.py
@@ -1,7 +1,7 @@
 from enum import Enum
 
 
-class RequestType(Enum):
+class RequestType(str, Enum):
     POST = "POST"
     PUT = "PUT"
     GET = "GET"
diff --git a/pdap_access_manager/src/models/__init__.py b/pdap_access_manager/src/models/__init__.py
diff --git a/pdap_access_manager/src/models/request.py b/pdap_access_manager/src/models/request.py
@@ -3,7 +3,7 @@
 from boltons import urlutils
 from pydantic import BaseModel
 
-from pdap_access_manager import RequestType
+from enums import RequestType
 
 
 class RequestInfo(BaseModel):
diff --git a/pdap_access_manager/src/models/response.py b/pdap_access_manager/src/models/response.py
diff --git a/tests/conftest.py b/tests/conftest.py
@@ -0,0 +1,20 @@
+from unittest.mock import AsyncMock
+
+import pytest
+from aiohttp import ClientSession
+
+from access_manager import AccessManager
+
+
+@pytest.fixture
+def access_manager():
+    mock_session = AsyncMock(
+        name="mock_session",
+        spec=ClientSession
+    )
+    access_manager = AccessManager(
+        email="email",
+        password="password",
+        session=mock_session,
+    )
+    return access_manager
diff --git a/tests/test_access_manager.py b/tests/test_access_manager.py
diff --git a/tests/test_failure_no_retry.py b/tests/test_failure_no_retry.py
@@ -0,0 +1,38 @@
+from http import HTTPStatus
+from unittest.mock import AsyncMock, MagicMock
+
+from aiohttp import ClientResponseError
+
+
+async def test_access_manager_refresh_access_token_failure_no_retry(
+    access_manager
+):
+    """
+    If the request made by refresh_access_token fails,
+    it should not be retried,
+    and a new login should be performed
+    :return:
+    """
+
+    access_manager.jwt_header = AsyncMock(return_value={"Authorization": "Bearer token"})
+
+    access_manager.login = AsyncMock(name="mock_login")
+    post_response = MagicMock(name="post_response")
+    post_response.status = 200
+    post_response.raise_for_status.side_effect = ClientResponseError(
+        request_info=MagicMock(),
+        history=None,
+        status=HTTPStatus.UNAUTHORIZED.value,
+        message="Internal Server Error"
+    )
+
+    mock_session_post = MagicMock(name="mock_session_post")
+    mock_session_post.return_value.__aenter__.return_value = post_response
+    access_manager.session.post = mock_session_post
+
+    await access_manager.refresh_access_token()
+
+    post_response.raise_for_status.assert_called_once()
+
+    # Check that login called Twice
+    assert access_manager.login.call_count == 2
diff --git a/tests/test_happy_path.py b/tests/test_happy_path.py
@@ -0,0 +1,33 @@
+from http import HTTPStatus
+from unittest.mock import AsyncMock
+
+from enums import RequestType
+from models.request import RequestInfo
+
+
+async def test_access_manager_happy_path(access_manager):
+
+    # Mocking the method (e.g., get/post) and the response context manager
+    mock_response = AsyncMock()
+    mock_response.status = 200
+    mock_response.json.return_value = {
+        "key": "value"
+    }
+    mock_response.raise_for_status.return_value = None
+
+    mock_cm = AsyncMock()
+    mock_cm.__aenter__.return_value = mock_response
+    access_manager.session.post.return_value = mock_cm
+
+    ri = RequestInfo(
+        type_=RequestType.POST,
+        url="url",
+        json_={"email": "email", "password": "password"}
+    )
+
+    result = await access_manager.make_request(ri)
+
+    assert result.status_code == HTTPStatus.OK
+    assert result.data == {
+        "key": "value"
+    }
diff --git a/tests/test_refresh_on_401.py b/tests/test_refresh_on_401.py
@@ -0,0 +1,43 @@
+from unittest.mock import AsyncMock, MagicMock
+
+from aiohttp import ClientResponseError
+
+from enums import RequestType
+from models.request import RequestInfo
+
+
+async def test_access_manager_refresh_on_401(access_manager):
+    access_manager.refresh_access_token = AsyncMock()
+    access_manager.jwt_header = AsyncMock(return_value={"Authorization": "Bearer token"})
+
+    # First response raises 401
+    first_get_response = MagicMock(name="first_get_response")
+    first_get_response.raise_for_status.side_effect = ClientResponseError(
+        request_info=None,
+        history=None,
+        status=401,
+        message="Unauthorized"
+    )
+
+    # Second response succeeds
+    second_get_response = AsyncMock(name="second_get_response")
+    second_get_response.status = 200
+    second_get_response.raise_for_status.return_value = None
+    second_get_response.json.return_value = {"retried": True}
+
+    mock_session_get = MagicMock(name="mock_session_get")
+    mock_session_get.return_value.__aenter__.side_effect = [
+        first_get_response,
+        second_get_response
+    ]
+    access_manager.session.get = mock_session_get
+
+    ri = RequestInfo(
+        type_=RequestType.GET,
+        url="url"
+    )
+
+    result = await access_manager.make_request(ri)
+
+    assert result.data == {"retried": True}
+    access_manager.refresh_access_token.assert_called_once()
