continue refactoring

Author: giancarloromeo

packages/models-library/src/models_library/api_schemas_webserver/auth.py

@@ -78,7 +78,7 @@ class ApiKeyCreate(BaseModel):
 
 
 class ApiKeyGet(BaseModel):
-    id_: Annotated[int, Field(alias="id")]
+    id: int
     display_name: Annotated[str, Field(..., min_length=3)]
     api_base_url: HttpUrl | None = None
     api_key: str

services/web/server/src/simcore_service_webserver/api_keys/_api.py

@@ -42,10 +42,10 @@ def _generate_api_key_and_secret(name: str):
 async def create_api_key(
     app: web.Application,
     *,
-    display_name=str,
-    expiration=dt.timedelta,
     user_id: UserID,
     product_name: ProductName,
+    display_name=str,
+    expiration=dt.timedelta,
 ) -> ApiKey:
     # generate key and secret
     api_key, api_secret = _generate_api_key_and_secret(display_name)
@@ -80,19 +80,19 @@ async def get_api_key(
 async def get_or_create_api_key(
     app: web.Application,
     *,
-    name: str,
     user_id: UserID,
     product_name: ProductName,
+    display_name: str,
     expiration: dt.timedelta | None = None,
 ) -> ApiKey:
 
-    api_key, api_secret = _generate_api_key_and_secret(name)
+    api_key, api_secret = _generate_api_key_and_secret(display_name)
 
     return await _db.get_or_create(
         app,
         user_id=user_id,
         product_name=product_name,
-        display_name=name,
+        display_name=display_name,
         expiration=expiration,
         api_key=api_key,
         api_secret=api_secret,
@@ -107,7 +107,10 @@ async def delete_api_key(
     product_name: ProductName,
 ) -> None:
     await _db.delete(
-        app, api_key_id=api_key_id, user_id=user_id, product_name=product_name
+        app,
+        api_key_id=api_key_id,
+        user_id=user_id,
+        product_name=product_name,
     )
 
 

services/web/server/src/simcore_service_webserver/api_keys/_rest.py

@@ -47,11 +47,11 @@ async def list_api_keys(request: web.Request):
     return envelope_json_response(api_keys_names)
 
 
-@routes.get(f"/{API_VTAG}/auth/api-keys/{{api_key_id}}", name="api_key_get")
+@routes.get(f"/{API_VTAG}/auth/api-keys/{{api_key_id}}", name="get_api_key")
 @login_required
 @permission_required("user.apikey.*")
 @handle_plugin_requests_exceptions
-async def api_key_get(request: web.Request):
+async def get_api_key(request: web.Request):
     req_ctx = RequestContext.model_validate(request)
     path_params = parse_request_path_parameters_as(ApiKeysPathParams, request)
     api_key: ApiKey = await _api.get_api_key(

services/web/server/src/simcore_service_webserver/api_keys/_rpc.py

@@ -15,62 +15,72 @@
 
 
 @router.expose()
-async def create_api_keys(
+async def create_api_key(
     app: web.Application,
     *,
-    product_name: ProductName,
     user_id: UserID,
-    new: ApiKeyCreate,
+    product_name: ProductName,
+    api_key: ApiKeyCreate,
 ) -> ApiKeyGet:
     return await _api.create_api_key(
-        app, new=new, user_id=user_id, product_name=product_name
-    )
-
-
-@router.expose()
-async def delete_api_keys(
-    app: web.Application,
-    *,
-    product_name: ProductName,
-    user_id: UserID,
-    api_key_id: int,
-) -> None:
-    await _api.delete_api_key(
-        app, api_key_id=api_key_id, user_id=user_id, product_name=product_name
+        app,
+        user_id=user_id,
+        product_name=product_name,
+        display_name=api_key.display_name,
+        expiration=api_key.expiration,
     )
 
 
 @router.expose(reraise_if_error_type=(ApiKeyNotFoundError,))
-async def api_key_get(
+async def get_api_key(
     app: web.Application,
     *,
-    product_name: ProductName,
     user_id: UserID,
+    product_name: ProductName,
     api_key_id: int,
 ) -> ApiKeyGet | None:
     return await _api.get_api_key(
-        app, api_key_id=api_key_id, user_id=user_id, product_name=product_name
+        app,
+        user_id=user_id,
+        product_name=product_name,
+        api_key_id=api_key_id,
     )
 
 
 @router.expose()
-async def get_or_create_api_keys(
+async def get_or_create_api_key(
     app: web.Application,
     *,
-    product_name: ProductName,
     user_id: UserID,
-    name: str,
+    product_name: ProductName,
+    display_name: str,
     expiration: timedelta | None = None,
 ) -> ApiKeyGet:
     return await _api.get_or_create_api_key(
         app,
-        name=name,
         user_id=user_id,
         product_name=product_name,
+        display_name=display_name,
         expiration=expiration,
     )
 
 
+@router.expose()
+async def delete_api_key(
+    app: web.Application,
+    *,
+    user_id: UserID,
+    product_name: ProductName,
+    api_key_id: int,
+) -> None:
+    await _api.delete_api_key(
+        app,
+        user_id=user_id,
+        product_name=product_name,
+        api_key_id=api_key_id,
+    )
+
+
 async def register_rpc_routes_on_startup(app: web.Application):
     rpc_server = get_rabbitmq_rpc_server(app)
     await rpc_server.register_router(router, WEBSERVER_RPC_NAMESPACE, app)

services/web/server/tests/unit/with_dbs/01/test_api_keys.py

@@ -91,7 +91,7 @@ async def test_list_api_keys(
     "user_role,expected",
     _get_user_access_parametrizations(status.HTTP_200_OK),
 )
-async def test_create_api_keys(
+async def test_create_api_key(
     client: TestClient,
     logged_user: UserInfoDict,
     user_role: UserRole,
@@ -184,9 +184,9 @@ async def test_get_or_create_api_key(
         assert client.app
 
         options = {
-            "name": "foo",
             "user_id": user["id"],
             "product_name": "osparc",
+            "display_name": "foo",
         }
 
         # create once

services/web/server/tests/unit/with_dbs/01/test_api_keys_rpc.py

@@ -21,6 +21,7 @@
 from servicelib.rabbitmq import RabbitMQRPCClient
 from settings_library.rabbit import RabbitSettings
 from simcore_postgres_database.models.users import UserRole
+from simcore_service_webserver.api_keys._models import ApiKey
 from simcore_service_webserver.api_keys.errors import ApiKeyNotFoundError
 from simcore_service_webserver.application_settings import ApplicationSettings
 
@@ -59,15 +60,16 @@ def user_role() -> UserRole:
 
 
 @pytest.fixture
-async def fake_user_api_ids(
+async def fake_user_api_keys(
     user_role: UserRole,
     web_server: TestServer,
     logged_user: UserInfoDict,
     osparc_product_name: ProductName,
     faker: Faker,
-) -> AsyncIterable[list[int]]:
+) -> AsyncIterable[list[ApiKey]]:
     assert web_server.app
-    api_key_ids: list[int] = [
+
+    api_keys: list[ApiKey] = [
         await db.create(
             web_server.app,
             user_id=logged_user["id"],
@@ -80,12 +82,12 @@ async def fake_user_api_ids(
         for _ in range(5)
     ]
 
-    yield api_key_ids
+    yield api_keys
 
-    for api_key_id in api_key_ids:
+    for api_key in api_keys:
         await db.delete(
             web_server.app,
-            api_key_id=api_key_id,
+            api_key_id=api_key.id,
             user_id=logged_user["id"],
             product_name=osparc_product_name,
         )
@@ -99,21 +101,21 @@ async def rpc_client(
     return await rabbitmq_rpc_client("client")
 
 
-async def test_api_key_get(
-    fake_user_api_ids: list[int],
+async def test_get_api_key(
+    fake_user_api_keys: list[ApiKey],
     rpc_client: RabbitMQRPCClient,
     osparc_product_name: ProductName,
     logged_user: UserInfoDict,
 ):
-    for api_key_id in fake_user_api_ids:
+    for api_key in fake_user_api_keys:
         result = await rpc_client.request(
             WEBSERVER_RPC_NAMESPACE,
-            TypeAdapter(RPCMethodName).validate_python("api_key_get"),
+            TypeAdapter(RPCMethodName).validate_python("get_api_key"),
             product_name=osparc_product_name,
             user_id=logged_user["id"],
-            api_key_id=api_key_id,
+            api_key_id=api_key.id,
         )
-        assert result.id_ == api_key_id
+        assert result.id == api_key.id
 
 
 async def test_api_keys_workflow(
@@ -128,20 +130,20 @@ async def test_api_keys_workflow(
     # creating a key
     created_api_key = await rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
-        TypeAdapter(RPCMethodName).validate_python("create_api_keys"),
+        TypeAdapter(RPCMethodName).validate_python("create_api_key"),
         product_name=osparc_product_name,
         user_id=logged_user["id"],
-        new=ApiKeyCreate(display_name=key_name, expiration=None),
+        api_key=ApiKeyCreate(display_name=key_name, expiration=None),
     )
     assert created_api_key.display_name == key_name
 
     # query the key is still present
     queried_api_key = await rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
-        TypeAdapter(RPCMethodName).validate_python("api_key_get"),
+        TypeAdapter(RPCMethodName).validate_python("get_api_key"),
         product_name=osparc_product_name,
         user_id=logged_user["id"],
-        api_key_id=created_api_key.id_,
+        api_key_id=created_api_key.id,
     )
     assert queried_api_key.display_name == key_name
 
@@ -150,19 +152,19 @@ async def test_api_keys_workflow(
     # remove the key
     delete_key_result = await rpc_client.request(
         WEBSERVER_RPC_NAMESPACE,
-        TypeAdapter(RPCMethodName).validate_python("delete_api_keys"),
+        TypeAdapter(RPCMethodName).validate_python("delete_api_key"),
         product_name=osparc_product_name,
         user_id=logged_user["id"],
-        api_key_id=created_api_key.id_,
+        api_key_id=created_api_key.id,
     )
     assert delete_key_result is None
 
     with pytest.raises(ApiKeyNotFoundError):
         # key no longer present
         await rpc_client.request(
             WEBSERVER_RPC_NAMESPACE,
-            TypeAdapter(RPCMethodName).validate_python("api_key_get"),
+            TypeAdapter(RPCMethodName).validate_python("get_api_key"),
             product_name=osparc_product_name,
             user_id=logged_user["id"],
-            api_key_id=created_api_key.id_,
+            api_key_id=created_api_key.id,
         )