fixed all tests, trying to resolve warnings

Author: joeygrable94

requirements.txt

@@ -70,7 +70,6 @@ pytest==8.3.4
 pytest-asyncio==0.25.3
 pytest-cov==6.0.0
 pytest-profiling==1.8.1
-pytest-testmon==2.1.3
 python-dateutil==2.9.0.post0
 python-dotenv==1.0.1
 python-multipart==0.0.20

tests/app/routes/test_go_property-ga4_stream.py

@@ -44,6 +44,8 @@ async def ga4_stream_db_session(
 
 
 async def perform_test_list(
+    status_code: int,
+    error_msg: str | None,
     item_count: int,
     client: AsyncClient,
     ga4_stream_db_session: AsyncSession,
@@ -71,11 +73,14 @@ async def perform_test_list(
         headers=current_user.token_headers,
     )
     data: dict[str, Any] = response.json()
-    assert 200 <= response.status_code < 300
-    assert data["page"] == 1
-    assert data["total"] == item_count
-    assert data["size"] == 1000
-    assert len(data["results"]) == item_count
+    assert response.status_code == status_code
+    if error_msg is None:
+        assert data["page"] == 1
+        assert data["total"] == item_count
+        assert data["size"] == 1000
+        assert len(data["results"]) == item_count
+    else:
+        assert error_msg in data["detail"]
 
 
 async def perform_test_create(
@@ -385,23 +390,33 @@ class TestListGoPropertyGa4Stream:
     async def test_list_go_property_ga4_stream_by_id_as_admin_user(
         self, client, ga4_stream_db_session, admin_user
     ) -> None:
-        await perform_test_list(2, client, ga4_stream_db_session, admin_user)
+        await perform_test_list(200, None, 2, client, ga4_stream_db_session, admin_user)
 
     async def test_list_go_property_ga4_stream_by_id_as_manager_user(
         self, client, ga4_stream_db_session, manager_user
     ) -> None:
-        await perform_test_list(4, client, ga4_stream_db_session, manager_user)
+        await perform_test_list(
+            200, None, 4, client, ga4_stream_db_session, manager_user
+        )
 
     async def test_list_go_property_ga4_stream_by_id_as_employee_user(
         self, client, ga4_stream_db_session, employee_user
     ) -> None:
-        await perform_test_list(0, client, ga4_stream_db_session, employee_user)
+        await perform_test_list(
+            200, None, 0, client, ga4_stream_db_session, employee_user
+        )
 
-    @pytest.mark.xfail(reason=ERROR_MESSAGE_INSUFFICIENT_PERMISSIONS_PAGINATION)
     async def test_list_go_property_ga4_stream_by_id_as_verified_user(
         self, client, ga4_stream_db_session, verified_user
     ) -> None:
-        await perform_test_list(0, client, ga4_stream_db_session, verified_user)
+        await perform_test_list(
+            405,
+            ERROR_MESSAGE_INSUFFICIENT_PERMISSIONS_PAGINATION,
+            0,
+            client,
+            ga4_stream_db_session,
+            verified_user,
+        )
 
     # CASES
     async def test_list_go_property_ga4_stream_as_superuser_by_website_id(

tests/app/routes/test_public_secure.py

@@ -2,7 +2,6 @@
 from os import urandom
 from typing import Any
 
-import pytest
 from httpx import AsyncClient, Headers, Response
 from itsdangerous import URLSafeTimedSerializer
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -16,10 +15,18 @@
 
 
 async def perform_status_test(
-    client_user: ClientAuthorizedUser, status_code: int, client: AsyncClient
+    status_code: int,
+    error_msg: str | None,
+    client: AsyncClient,
+    current_user: ClientAuthorizedUser,
 ) -> None:
-    response = await client.get("/status", headers=client_user.token_headers)
+    response = await client.get("/status", headers=current_user.token_headers)
     assert response.status_code == status_code
+    entry: dict[str, Any] = response.json()
+    if error_msg is None:
+        assert entry["status"] == "ok"
+    else:
+        assert entry["detail"] == error_msg
 
 
 class TestPublicSecureRoutes:
@@ -54,38 +61,39 @@ async def test_encrypt_decrypt_message_as_admin(
     async def test_public_status_as_admin_user(
         self, admin_user: ClientAuthorizedUser, client: AsyncClient
     ) -> None:
-        await perform_status_test(admin_user, 200, client)
+        await perform_status_test(200, None, client, admin_user)
 
     async def test_public_status_as_manager_user(
         self, manager_user: ClientAuthorizedUser, client: AsyncClient
     ) -> None:
-        await perform_status_test(manager_user, 200, client)
+        await perform_status_test(200, None, client, manager_user)
 
     async def test_public_status_as_employee_user(
         self, employee_user: ClientAuthorizedUser, client: AsyncClient
     ) -> None:
-        await perform_status_test(employee_user, 200, client)
+        await perform_status_test(200, None, client, employee_user)
 
     async def test_public_status_as_client_a_user(
         self, client_a_user: ClientAuthorizedUser, client: AsyncClient
     ) -> None:
-        await perform_status_test(client_a_user, 200, client)
+        await perform_status_test(200, None, client, client_a_user)
 
     async def test_public_status_as_client_b_user(
         self, client_b_user: ClientAuthorizedUser, client: AsyncClient
     ) -> None:
-        await perform_status_test(client_b_user, 200, client)
+        await perform_status_test(200, None, client, client_b_user)
 
     async def test_public_status_as_verified_user(
         self, verified_user: ClientAuthorizedUser, client: AsyncClient
     ) -> None:
-        await perform_status_test(verified_user, 200, client)
+        await perform_status_test(200, None, client, verified_user)
 
-    @pytest.mark.xfail(reason=ERROR_MESSAGE_UNVERIFIED_ACCESS_DENIED)
     async def test_public_status_as_unverified_user(
         self, unverified_user: ClientAuthorizedUser, client: AsyncClient
     ) -> None:
-        await perform_status_test(unverified_user, 403, client)
+        await perform_status_test(
+            403, ERROR_MESSAGE_UNVERIFIED_ACCESS_DENIED, client, unverified_user
+        )
 
 
 class TestCsrfProtection:

tests/app/routes/test_websites.py

@@ -97,6 +97,7 @@ async def perform_test_create(
 
 
 async def perform_test_limits_create(
+    check_domain: bool,
     domain: str,
     is_secure: bool,
     status_code: int,
@@ -109,15 +110,22 @@ async def perform_test_limits_create(
 ) -> None:
     data: dict[str, Any] = {"domain": domain, "is_secure": is_secure}
     response: Response
-    with unittest.mock.patch(
-        "app.entities.website.crud.WebsiteRepository.validate"
-    ) as mock_validate_website_domain:
-        mock_validate_website_domain.return_value = valid_domain
+    if check_domain:
         response = await client.post(
             "websites/",
             headers=admin_user.token_headers,
             json=data,
         )
+    else:
+        with unittest.mock.patch(
+            "app.entities.website.crud.WebsiteRepository.validate"
+        ) as mock_validate_website_domain:
+            mock_validate_website_domain.return_value = valid_domain
+            response = await client.post(
+                "websites/",
+                headers=admin_user.token_headers,
+                json=data,
+            )
     assert response.status_code == status_code
     entry: dict[str, Any] = response.json()
     if error_type == "message":
@@ -182,6 +190,7 @@ async def perform_test_update(
 
 
 async def perform_test_limits_update(
+    check_domain: bool,
     domain: str | None,
     status_code: int,
     error_type: str,
@@ -197,17 +206,23 @@ async def perform_test_limits_update(
         update_dict = {"domain": a_website.domain, "is_secure": not a_website.is_secure}
     else:
         update_dict = {"domain": domain, "is_secure": not a_website.is_secure}
-
     response: Response
-    with unittest.mock.patch(
-        "app.entities.website.crud.WebsiteRepository.validate"
-    ) as mock_validate_website_domain:
-        mock_validate_website_domain.return_value = valid_domain
+    if check_domain:
         response: Response = await client.patch(
             f"websites/{a_website.id}",
             headers=admin_user.token_headers,
             json=update_dict,
         )
+    else:
+        with unittest.mock.patch(
+            "app.entities.website.crud.WebsiteRepository.validate"
+        ) as mock_validate_website_domain:
+            mock_validate_website_domain.return_value = valid_domain
+            response: Response = await client.patch(
+                f"websites/{a_website.id}",
+                headers=admin_user.token_headers,
+                json=update_dict,
+            )
     entry: dict[str, Any] = response.json()
     assert response.status_code == status_code
     if error_type == "message":
@@ -319,14 +334,14 @@ async def test_create_website_as_unverified_user(
         )
 
     # LIMITS
-    @pytest.mark.xfail(reason=ERROR_MESSAGE_DOMAIN_INVALID)
     async def test_create_website_as_admin_user_website_limits_domain_invalid(
         self, client, db_session, admin_user
     ) -> None:
         await perform_test_limits_create(
+            True,
             random_domain(16, "co"),
             random_boolean(),
-            400,
+            422,
             "message",
             ERROR_MESSAGE_DOMAIN_INVALID,
             True,
@@ -339,6 +354,7 @@ async def test_create_website_as_admin_user_website_limits_domain_short(
         self, client, db_session, admin_user
     ) -> None:
         await perform_test_limits_create(
+            False,
             random_domain(1, "co"),
             random_boolean(),
             422,
@@ -354,6 +370,7 @@ async def test_create_website_as_admin_user_website_limits_domain_long(
         self, client, db_session, admin_user
     ) -> None:
         await perform_test_limits_create(
+            False,
             random_domain(DB_STR_TINYTEXT_MAXLEN_INPUT + 1, "com"),
             random_boolean(),
             422,
@@ -371,6 +388,7 @@ async def test_create_website_as_admin_user_website_limits_domain_schema_invalid
         self, client, db_session, admin_user
     ) -> None:
         await perform_test_limits_create(
+            False,
             "https://" + random_domain(3, "pub"),
             random_boolean(),
             422,
@@ -543,6 +561,7 @@ async def test_update_website_as_superuser_website_limits_domain_exists(
         self, client, db_session, admin_user
     ) -> None:
         await perform_test_limits_update(
+            False,
             None,
             400,
             "message",
@@ -553,13 +572,13 @@ async def test_update_website_as_superuser_website_limits_domain_exists(
             admin_user,
         )
 
-    @pytest.mark.xfail(reason=ERROR_MESSAGE_DOMAIN_INVALID)
     async def test_update_website_as_superuser_website_limits_domain_invalid(
         self, client, db_session, admin_user
     ) -> None:
         await perform_test_limits_update(
+            True,
             random_domain(16, "co"),
-            400,
+            422,
             "message",
             ERROR_MESSAGE_DOMAIN_INVALID,
             True,
@@ -572,6 +591,7 @@ async def test_update_website_as_superuser_website_limits_domain_short(
         self, client, db_session, admin_user
     ) -> None:
         await perform_test_limits_update(
+            False,
             "a.co",
             422,
             "detail",
@@ -586,6 +606,7 @@ async def test_update_website_as_superuser_website_limits_domain_long(
         self, client, db_session, admin_user
     ) -> None:
         await perform_test_limits_update(
+            False,
             random_lower_string() * 10 + ".com",
             422,
             "detail",
@@ -602,6 +623,7 @@ async def test_update_website_as_superuser_website_limits_domain_invalid_schema(
         self, client, db_session, admin_user
     ) -> None:
         await perform_test_limits_update(
+            False,
             "https://" + random_lower_string() + ".com",
             422,
             "detail",