#812 Attempted fix to modifier tests

Author: bogadisa

src/backend_api/app/api/routes/currency.py

@@ -135,7 +135,7 @@ async def create_currency(
 
 
 @router.put(
-    "/{currencyId}",
+    "/",
     response_model=schemas.Currency,
     dependencies=[
         Depends(get_current_active_superuser),
@@ -162,7 +162,7 @@ async def update_currency(
 
 
 @router.delete(
-    "/{currencyId}",
+    "/",
     response_model=str,
     dependencies=[
         Depends(get_current_active_superuser),

src/backend_api/app/api/routes/item_base_type.py

@@ -113,7 +113,7 @@ async def create_item_base_type(
 
 
 @router.put(
-    "/{itemBaseTypeId}",
+    "/",
     response_model=schemas.ItemBaseType,
     dependencies=[
         Depends(get_current_active_superuser),
@@ -141,7 +141,7 @@ async def update_item_base_type(
 
 
 @router.delete(
-    "/{itemBaseTypeId}",
+    "/",
     response_model=str,
     dependencies=[Depends(get_current_active_superuser)],
 )

src/backend_api/app/tests/test_simulating_env/api/api_routes_test_base.py

@@ -176,7 +176,7 @@ async def test_create_on_duplicate_pkey(
         on_duplicate_params: tuple[bool, str | None],
     ) -> None:
         """Test create found duplicate instance"""
-        on_duplicate_pkey_do_nothing = on_duplicate_params[0]
+        # on_duplicate_pkey_do_nothing = on_duplicate_params[0]
         # if not on_duplicate_pkey_do_nothing:
         # TODO: Make test database mock with unique constraints
         pytest.skip(
@@ -398,7 +398,6 @@ async def test_update_instance(
         object_generator_func: Callable[[], tuple[dict, ModelType]],
         route_prefix: str,
         model_table_name: str,
-        unique_identifier: str,
         update_request_params: bool,
         ignore_test_columns: list[str],
         is_hypertable: bool,
@@ -429,7 +428,8 @@ async def test_update_instance(
         update_obj_pk_map = self._create_primary_key_map(update_object_out)
 
         delete_response = await async_client.delete(
-            f"{settings.API_V1_STR}/{route_prefix}/{update_obj_pk_map[unique_identifier]}",
+            f"{settings.API_V1_STR}/{route_prefix}/",
+            params=update_obj_pk_map,
             headers=superuser_token_headers,
         )  # delete the object to avoid unique constraint errorspå
         assert delete_response.status_code == 200
@@ -439,24 +439,18 @@ async def test_update_instance(
             content_delete
             == get_delete_return_msg(
                 model_table_name=model_table_name,
-                filter={unique_identifier: update_obj_pk_map[unique_identifier]},
+                filter=update_obj_pk_map,
             ).message
         )
 
         if update_request_params:
             obj_out_pk_map = self._create_primary_key_map(object_out)
-            response = await async_client.put(
-                f"{settings.API_V1_STR}/{route_prefix}/",
-                headers=superuser_token_headers,
-                json=update_object_dict,
-                params=obj_out_pk_map,
-            )
-        else:
-            response = await async_client.put(
-                f"{settings.API_V1_STR}/{route_prefix}/{obj_out_pk_map[unique_identifier]}",
-                headers=superuser_token_headers,
-                json=update_object_dict,
-            )
+        response = await async_client.put(
+            f"{settings.API_V1_STR}/{route_prefix}/",
+            headers=superuser_token_headers,
+            json=update_object_dict,
+            params=obj_out_pk_map,
+        )
         assert response.status_code == 200
         content = response.json()
 
@@ -476,8 +470,6 @@ async def test_update_instance_not_found(
         object_generator_func: Callable[[], tuple[dict, ModelType]],
         route_prefix: str,
         model_table_name: str,
-        update_request_params: bool,
-        unique_identifier: str,
         is_hypertable: bool,
     ) -> None:
         """Test update instance not found
@@ -507,7 +499,8 @@ async def test_update_instance_not_found(
         update_obj_out_pk_map = self._create_primary_key_map(update_object_out)
 
         delete_response = await async_client.delete(
-            f"{settings.API_V1_STR}/{route_prefix}/{update_obj_out_pk_map[unique_identifier]}",
+            f"{settings.API_V1_STR}/{route_prefix}/",
+            params=update_obj_out_pk_map,
             headers=superuser_token_headers,
         )  # delete the object to avoid unique constraint errors
         assert delete_response.status_code == 200
@@ -518,27 +511,20 @@ async def test_update_instance_not_found(
             content_delete
             == get_delete_return_msg(
                 model_table_name=model_table_name,
-                filter={unique_identifier: update_obj_out_pk_map[unique_identifier]},
+                filter=update_obj_out_pk_map,
             ).message
         )
 
         not_found_object = 999
         for key in update_obj_out_pk_map:
             update_obj_out_pk_map[key] = not_found_object
 
-        if update_request_params:
-            response = await async_client.put(
-                f"{settings.API_V1_STR}/{route_prefix}/",
-                headers=superuser_token_headers,
-                json=update_object_dict,
-                params=update_obj_out_pk_map,
-            )
-        else:
-            response = await async_client.put(
-                f"{settings.API_V1_STR}/{route_prefix}/{not_found_object}",
-                headers=superuser_token_headers,
-                json=update_object_dict,
-            )
+        response = await async_client.put(
+            f"{settings.API_V1_STR}/{route_prefix}/",
+            headers=superuser_token_headers,
+            json=update_object_dict,
+            params=update_obj_out_pk_map,
+        )
 
         db_obj_does_not_exist_error = DbObjectDoesNotExistError(
             model_table_name=model_table_name,
@@ -558,8 +544,6 @@ async def test_update_instance_not_enough_permissions(
         route_prefix: str,
         model_table_name: str,
         superuser_token_headers: dict[str, str],
-        unique_identifier: str,
-        update_request_params: bool,
         is_hypertable: bool,
     ) -> None:
         """Test update instance not enough permissions
@@ -591,7 +575,8 @@ async def test_update_instance_not_enough_permissions(
         update_obj_pk_map = self._create_primary_key_map(update_object_out)
 
         delete_response = await async_client.delete(
-            f"{settings.API_V1_STR}/{route_prefix}/{update_obj_pk_map[unique_identifier]}",
+            f"{settings.API_V1_STR}/{route_prefix}/",
+            params=update_obj_pk_map,
             headers=superuser_token_headers,
         )  # delete the object to avoid unique constraint errors
         assert delete_response.status_code == 200
@@ -602,21 +587,15 @@ async def test_update_instance_not_enough_permissions(
             content_delete
             == get_delete_return_msg(
                 model_table_name=model_table_name,
-                filter={unique_identifier: update_obj_pk_map[unique_identifier]},
+                filter=update_obj_pk_map,
             ).message
         )
 
-        if update_request_params:
-            response = await async_client.put(
-                f"{settings.API_V1_STR}/{route_prefix}/",
-                json=update_object_dict,
-                params=obj_pk_map,
-            )
-        else:
-            response = await async_client.put(
-                f"{settings.API_V1_STR}/{route_prefix}/{obj_pk_map[unique_identifier]}",
-                json=update_object_dict,
-            )
+        response = await async_client.put(
+            f"{settings.API_V1_STR}/{route_prefix}/",
+            json=update_object_dict,
+            params=obj_pk_map,
+        )
         invalid_token_error = InvalidTokenError(
             token=None,
             function_name=UserCache.verify_token.__name__,
@@ -635,7 +614,6 @@ async def test_delete_instance(
         object_generator_func: Callable[[], tuple[dict, ModelType]],
         route_prefix: str,
         model_table_name: str,
-        unique_identifier: str,
         is_hypertable: bool,
     ) -> None:
         """Test delete instance
@@ -660,7 +638,8 @@ async def test_delete_instance(
         update_obj_pk_map = self._create_primary_key_map(update_object_out)
 
         response = await async_client.delete(
-            f"{settings.API_V1_STR}/{route_prefix}/{update_obj_pk_map[unique_identifier]}",
+            f"{settings.API_V1_STR}/{route_prefix}/",
+            params=update_obj_pk_map,
             headers=superuser_token_headers,
         )
         assert response.status_code == 200
@@ -670,18 +649,19 @@ async def test_delete_instance(
             content
             == get_delete_return_msg(
                 model_table_name=model_table_name,
-                filter={unique_identifier: update_obj_pk_map[unique_identifier]},
+                filter=update_obj_pk_map,
             ).message
         )
 
     @pytest.mark.anyio
     async def test_delete_instance_not_found(
         self,
         async_client: AsyncClient,
+        db: Session,
         superuser_token_headers: dict[str, str],
+        object_generator_func: Callable[[], tuple[dict, ModelType]],
         route_prefix: str,
         model_table_name: str,
-        unique_identifier: str,
         crud_instance: CRUDBase,
         is_hypertable: bool,
     ) -> None:
@@ -697,14 +677,23 @@ async def test_delete_instance_not_found(
         if is_hypertable:
             pytest.skip("Hypertables doesn't support delete object operations")
 
-        not_found_object = 999
+        object_dict, object_out = await self._create_random_object_crud(
+            db, object_generator_func
+        )  # create the object to update and add to the db
+        self._test_object(object_out, object_dict)
+
+        delete_obj_out_pk_map = self._create_primary_key_map(object_out)
+        for key in delete_obj_out_pk_map.keys():
+            delete_obj_out_pk_map[key] = 999
+
         response = await async_client.delete(
-            f"{settings.API_V1_STR}/{route_prefix}/{not_found_object}",
+            f"{settings.API_V1_STR}/{route_prefix}/",
+            params=delete_obj_out_pk_map,
             headers=superuser_token_headers,
         )
         db_obj_not_exists_error = DbObjectDoesNotExistError(
             model_table_name=model_table_name,
-            filter={unique_identifier: not_found_object},
+            filter=delete_obj_out_pk_map,
             function_name=crud_instance.remove.__name__,
             class_name=crud_instance.__class__.__name__,
         )
@@ -719,7 +708,6 @@ async def test_delete_instance_not_enough_permissions(
         db: Session,
         object_generator_func: Callable[[], tuple[dict, ModelType]],
         route_prefix: str,
-        unique_identifier: str,
         is_hypertable: bool,
     ) -> None:
         """Test delete instance not enough permissions
@@ -740,7 +728,7 @@ async def test_delete_instance_not_enough_permissions(
         _, object_out = await self._create_random_object_crud(db, object_generator_func)
         obj_out_pk_map = self._create_primary_key_map(object_out)
         response = await async_client.delete(
-            f"{settings.API_V1_STR}/{route_prefix}/{obj_out_pk_map[unique_identifier]}",
+            f"{settings.API_V1_STR}/{route_prefix}/", params=obj_out_pk_map
         )
         invalid_token_error = InvalidTokenError(
             token=None,

src/backend_api/app/tests/test_simulating_env/api/routes/test_modifier.py

@@ -107,13 +107,14 @@ def create_random_object_func() -> Callable[[], dict]:
 async def get_object_from_api_normal_user(
     async_client: AsyncClient,
     route_prefix: str,
-    unique_identifier: str,
+    _: str,
     normal_user_token_headers: dict[str, str],
 ) -> Callable[[Any, Any], Awaitable[Any]]:
     async def _get_object(object_pk_map: dict[str, Any]) -> Response:
         response = await async_client.get(
-            f"{settings.API_V1_STR}/{route_prefix}/{object_pk_map[unique_identifier]}",
+            f"{settings.API_V1_STR}/{route_prefix}/",
             headers=normal_user_token_headers,
+            params=object_pk_map,
         )
         return response