enabled syntax highlighting for queries

server/.gitignore

@@ -175,4 +175,5 @@ pyrightconfig.json
 
 # End of https://www.toptal.com/developers/gitignore/api/python
 
-*.log
+*.log
+.vscode/

server/app/controllers/events.py

@@ -50,7 +50,7 @@ class EventController(BaseController):
         :raises HTTPException: If any error occurs (status code 500)
         :return list[EventSeries]: A list of EventSeries objects suitable for a response body
         """
-        series_data = self.db.select_all_series()
+        series_data = self.db.select_all()
 
         try:
             return [series for series in self._all_series(series_data).values()]

server/app/controllers/musicians.py

@@ -32,7 +32,7 @@ class MusicianController(BaseController):
         :raises HTTPException: If any error occurs during the retrieval process (status code 500)
         :return list[Musician]: A list of Musician objects suitable for a response body
         """
-        data = self.db.select_all_series()
+        data = self.db.select_all()
         try:
             return [Musician(**m) for m in data]
         except Exception as e:

server/app/controllers/users.py

@@ -30,7 +30,7 @@ class UserController(BaseController):
         :raises HTTPException: If any error occurs during the retrieval process (status code 500)
         :return list[User]: A list of User objects suitable for a response body
         """
-        data = self.db.select_all_series()
+        data = self.db.select_all()
         try:
             return [User(**e) for e in data]
         except Exception as e:

server/app/db/base_queries.py

@@ -1,6 +1,8 @@
 from typing import Callable
 
 from icecream import ic
+from mysql.connector.connection import MySQLConnection
+from mysql.connector.cursor import MySQLCursor
 
 from app.db.conn import connect_db
 
@@ -15,25 +17,39 @@ class BaseQueries:
 
     def __init__(self) -> None:
         self.table: str = None  # type: ignore
-        self.connect_db: Callable = connect_db
+        self.connect_db: Callable[[], MySQLConnection] = connect_db
 
-    def select_all_series(self) -> list[dict]:
+    def select_all(self) -> list[dict]:
-        query = f"SELECT * FROM {self.table}"
+        query = f"""-- sql
-        db = connect_db()
+            SELECT * FROM {self.table}
-        cursor = db.cursor(dictionary=True)
+            """
+        cursor, conn = self.get_cursor_and_conn()
         cursor.execute(query)
-        data = cursor.fetchall()
+        data: list[dict] = cursor.fetchall()  # type: ignore
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()
+
-        return data  # type: ignore
+        fake_query = f"""-- sql
+            select * from dogs
+        """
+
+        return data
 
     def select_one_by_id(self, id: int) -> dict | None:
-        query = f"SELECT * FROM {self.table} WHERE id = %s"
+        query = f"""-- sql
-        db = self.connect_db()
+            SELECT * FROM {self.table} WHERE id = %s
-        cursor = db.cursor(dictionary=True)
+            """
+        cursor, conn = self.get_cursor_and_conn()
         cursor.execute(query, (id,))
-        data = cursor.fetchone()
+        data: dict | None = cursor.fetchone()  # type: ignore
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()
 
-        return data  # type: ignore
+        return data
+
+    def get_cursor_and_conn(self) -> tuple[MySQLCursor, MySQLConnection]:
+        conn = self.connect_db()
+        cursor = conn.cursor(dictionary=True)
+        return cursor, conn
+
+    def close_cursor_and_conn(self, cursor: MySQLCursor, conn: MySQLConnection) -> None:
+        cursor.close()
+        conn.close()

server/app/db/events.py

@@ -1,5 +1,3 @@
-from asyncio import gather
-
 from icecream import ic
 
 from app.constants import EVENT_TABLE, SERIES_TABLE
@@ -15,52 +13,46 @@ class EventQueries(BaseQueries):
 
     def __init__(self) -> None:
         super().__init__()
-        self.table = SERIES_TABLE
 
     def select_one_by_id(self, series_id: int) -> list[dict] | None:
-        query = f"""
+        query = f"""-- sql
-            SELECT s.series_id , s.name , s.description , s.poster_id , e.event_id , e.location , e.`time` , e.ticket_url , e.map_url
+                SELECT s.series_id , s.name , s.description , s.poster_id , e.event_id , e.location , e.`time` , e.ticket_url , e.map_url
-            FROM {SERIES_TABLE} s
+                FROM {SERIES_TABLE} s
-            LEFT JOIN {EVENT_TABLE} e
+                LEFT JOIN {EVENT_TABLE} e
-            ON s.series_id = e.series_id
+                ON s.series_id = e.series_id
-            WHERE s.series_id = %s
+                WHERE s.series_id = %s
-        """
+            """
-        db = self.connect_db()
+        cursor, conn = self.get_cursor_and_conn()
-        cursor = db.cursor(dictionary=True)
         cursor.execute(query, (series_id,))
-        data = cursor.fetchall()
+        data: list[dict] = cursor.fetchall()  # type: ignore
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()
         return data
 
-    def select_all_series(self) -> list[dict]:
+    def select_all(self) -> list[dict]:
         """
         Queries for all Series and Event info and returns a list of dictionaries.
         Data is gathered with a LEFT JOIN on the Event table to ensure all Series are returned.
         A Series with no Events is valid.
         """
-        query = f"""
+        query = f"""-- sql
                 SELECT s.series_id , s.name , s.description , s.poster_id , e.event_id , e.location , e.`time` , e.ticket_url , e.map_url
                 FROM {SERIES_TABLE} s
                 LEFT JOIN {EVENT_TABLE} e
                 ON s.series_id = e.series_id
             """
 
-        db = self.connect_db()
+        cursor, conn = self.get_cursor_and_conn()
-        cursor = db.cursor(dictionary=True)
         cursor.execute(query)
-        data = cursor.fetchall()
+        data: list[dict] = cursor.fetchall()  # type: ignore
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()
         return data
 
     def insert_one_series(self, series: NewEventSeries) -> int:
-        query = f"""
+        query = f"""-- sql
-            INSERT INTO {self.table} (name, description)
+            INSERT INTO {SERIES_TABLE} (name, description)
             VALUES (%s, %s)
             """
-        db = self.connect_db()
+        cursor, conn = self.get_cursor_and_conn()
-        cursor = db.cursor()
         cursor.execute(
             query,
             (
@@ -69,91 +61,87 @@ class EventQueries(BaseQueries):
             ),
         )
         inserted_id = cursor.lastrowid
-        db.commit()
+        conn.commit()
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()
+
+        if inserted_id is None:
+            raise Exception("insertion error")
+
         return inserted_id
 
     def insert_one_event(self, event: NewEvent, series_id: int) -> int:
-        query = f"""
+        query = f"""-- sql
             INSERT INTO {EVENT_TABLE} (series_id, location, time, ticket_url, map_url)
             VALUES (%s, %s, %s, %s, %s)
             """
-        db = self.connect_db()
+        cursor, conn = self.get_cursor_and_conn()
-        cursor = db.cursor()
         ticket_url = str(event.ticket_url) if event.ticket_url else None
         map_url = str(event.map_url) if event.map_url else None
         cursor.execute(
             query, (series_id, event.location, event.time, ticket_url, map_url)
         )
-        iserted_id = cursor.lastrowid
+        inserted_id = cursor.lastrowid
-        db.commit()
+        conn.commit()
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()
+        if inserted_id is None:
-        return iserted_id
+            raise Exception("error inserting event")
+        return inserted_id
 
     def delete_events_by_series(self, series: EventSeries) -> None:
-        query = f"""
+        query = f"""-- sql
             DELETE FROM {EVENT_TABLE} 
             WHERE series_id = %s
             """
-        db = self.connect_db()
+        cursor, conn = self.get_cursor_and_conn()
-        cursor = db.cursor()
         cursor.execute(query, (series.series_id,))
-        db.commit()
+        conn.commit()
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
 
     def delete_one_series(self, series: EventSeries) -> None:
-        query = f"""
+        query = f"""-- sql
-            DELETE FROM {self.table}
+            DELETE FROM {SERIES_TABLE}
             WHERE series_id = %s
             """
-        db = self.connect_db()
+        cursor, conn = self.get_cursor_and_conn()
-        cursor = db.cursor()
         cursor.execute(query, (series.series_id,))
-        db.commit()
+        conn.commit()
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
 
     def update_series_poster(self, series: EventSeries) -> None:
-        query = f"""
+        query = f"""-- sql
-            UPDATE {self.table}
+            UPDATE {SERIES_TABLE}
             SET poster_id = %s
             WHERE series_id = %s
             """
-        db = self.connect_db()
+        cursor, conn = self.get_cursor_and_conn()
-        cursor = db.cursor()
         cursor.execute(query, (series.poster_id, series.series_id))
-        db.commit()
+        conn.commit()
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
 
     def replace_event(self, event: Event) -> None:
-        query = f"""
+        query = f"""-- sql
             UPDATE {EVENT_TABLE}
             SET location = %s, time = %s, ticket_url = %s, map_url = %s
             WHERE event_id = %s
             """
-        db = self.connect_db()
+        cursor, conn = self.get_cursor_and_conn()
-        cursor = db.cursor()
         ticket_url = str(event.ticket_url) if event.ticket_url else None
         map_url = str(event.map_url) if event.map_url else None
         cursor.execute(
             query, (event.location, event.time, ticket_url, map_url, event.event_id)
         )
-        db.commit()
+        conn.commit()
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()
 
     def replace_series(self, series: EventSeries) -> None:
-        query = f"""
+        query = f"""-- sql
-            UPDATE {self.table}
+            UPDATE {SERIES_TABLE}
             SET name = %s, description = %s, poster_id = %s
             WHERE series_id = %s
             """
-        db = self.connect_db()
+        cursor, conn = self.get_cursor_and_conn()
-        cursor = db.cursor()
         cursor.execute(
             query, (series.name, series.description, series.poster_id, series.series_id)
         )
-        db.commit()
+        conn.commit()
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()

server/app/db/group.py

@@ -8,29 +8,29 @@ class GroupQueries(BaseQueries):
         self.table = GROUP_TABLE
 
     def select_one_by_id(self) -> dict:
-        query = f"SELECT * FROM {self.table}"
+        query = f"""-- sql
-        db = self.connect_db()
+            SELECT * FROM {self.table}
-        cursor = db.cursor(dictionary=True)
+            """
+        cursor, conn = self.get_cursor_and_conn()
         cursor.execute(query)
-        data = cursor.fetchone()
+        data: dict = cursor.fetchone()  # type: ignore
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()
 
         if not data:
             raise Exception("error retrieving group")
 
         return data
 
-    def select_all_series(self) -> None:
+    def select_all(self) -> None:
         raise NotImplementedError(
             "get_all method not implemented for GroupQueries. There's only one row in the table."
         )
 
     def update_group_bio(self, bio: str) -> None:
-        db = self.connect_db()
+        cursor, conn = self.get_cursor_and_conn()
-        cursor = db.cursor()
+        query = f"""-- sql
-        query = f"UPDATE {self.table} SET bio = %s WHERE id = 1"  # only one row in the table
+            UPDATE {self.table} SET bio = %s WHERE id = 1
+            """  # only one row in the table
         cursor.execute(query, (bio,))
-        db.commit()
+        conn.commit()
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()

server/app/db/musicians.py

@@ -20,7 +20,9 @@ class MusicianQueries(BaseQueries):
         """
         db = connect_db()
         cursor = db.cursor()
-        query = f"UPDATE {self.table} SET bio = %s WHERE id = %s"
+        query = f"""-- sql
+            UPDATE {self.table} SET bio = %s WHERE id = %s
+            """
         cursor.execute(query, (bio, musician.id))
         db.commit()
         cursor.close()
@@ -36,7 +38,9 @@ class MusicianQueries(BaseQueries):
         """
         db = connect_db()
         cursor = db.cursor()
-        query = f"UPDATE {self.table} SET headshot_id = %s WHERE id = %s"
+        query = f"""-- sql
+            UPDATE {self.table} SET headshot_id = %s WHERE id = %s
+            """
         cursor.execute(query, (headshot_id, musician.id))
         db.commit()
         cursor.close()

server/app/db/users.py

@@ -3,40 +3,59 @@ from app.db.base_queries import BaseQueries
 
 
 class UserQueries(BaseQueries):
+    """
+    Used for quering the database for User related data
+    """
+
     def __init__(self) -> None:
         super().__init__()
         self.table = USER_TABLE
 
     def select_one_by_email(self, email: str) -> dict | None:
-        query = f"SELECT * FROM {self.table} WHERE email = %s"
+        """
-        db = self.connect_db()
+        Select one user by their email address
-        cursor = db.cursor(dictionary=True)
+
+        :param str email: user email
+        :return dict | None: a dictionary of found data, or None if no user found
+        """
+        query = f"""-- sql
+            SELECT * FROM {USER_TABLE} WHERE email = %s
+            """
+        cursor, conn = self.get_cursor_and_conn()
         cursor.execute(query, (email,))
-        data = cursor.fetchone()
+        data: dict = cursor.fetchone()  # type: ignore
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()
 
         return data
 
     def select_one_by_sub(self, sub: str) -> dict | None:
-        query = f"SELECT * FROM {self.table} WHERE sub = %s"
+        """
-        db = self.connect_db()
+        Select one user by their unique sub identifier
-        cursor = db.cursor(dictionary=True)
-        cursor.execute(query, (sub,))
-        data = cursor.fetchone()
-        cursor.close()
-        db.close()
 
-        if not data:
+        :param str sub: user sub
-            return None
+        :return dict | None: a dict of user data
+        """
+        query = f"""-- sql
+            SELECT * FROM {USER_TABLE} WHERE sub = %s
+            """
+        cursor, conn = self.get_cursor_and_conn()
+        cursor.execute(query, (sub,))
+        data: dict = cursor.fetchone()  # type: ignore
+        self.close_cursor_and_conn(cursor, conn)
 
         return data
 
     def update_sub(self, email: str, sub: str) -> None:
-        query = f"UPDATE {self.table} SET sub = %s WHERE email = %s"
+        """
-        db = self.connect_db()
+        Update user sub. Used when a user logs in for the first time.
-        cursor = db.cursor()
+
+        :param str email: user email
+        :param str sub: the new unique sub identifier
+        """
+        query = f"""-- sql
+            UPDATE {USER_TABLE} SET sub = %s WHERE email = %s
+            """
+        cursor, conn = self.get_cursor_and_conn()
         cursor.execute(query, (sub, email))
-        db.commit()
+        conn.commit()
-        cursor.close()
+        self.close_cursor_and_conn(cursor, conn)
-        db.close()

server/app/scripts/seed.py

@@ -82,32 +82,13 @@ series1 = EventSeries(
     series_id=0,
 )
 
-# series2 = EventSeries(
-#     name="The Grapefruits Duo Features: Solos for Bass Trombone",
-#     description="Pieces by Ewazen, Bozza, and more!",
-#     events=[
-#         Event(
-#             location="Eugene Family YMCA",
-#             time=datetime(2024, 7, 1, 17, 30),
-#             event_id=0,
-#         ),
-#         Event(
-#             location="Tobi's Crate",
-#             time=datetime(2024, 7, 2, 20),
-#             event_id=0,
-#             ticket_url="http://www.example.com",  # type: ignore
-#         ),
-#     ],
-#     id=0,
-# )
-
 
 def seed():
     confirmation = input(
         "Are you sure you want to seed the database? Data will be lost. [Y/n]: "
     )
     if confirmation.lower() not in ["y", "yes", ""]:
-        print("Exiting")
+        print("Exiting without changes")
         return
     print("Seeding database")
     add_musicians()
@@ -121,10 +102,12 @@ def add_group():
     db = connect_db()
     cursor = db.cursor()
     cursor.execute(
-        f"DROP TABLE IF EXISTS {GROUP_TABLE};",
+        f"""-- sql
+        DROP TABLE IF EXISTS {GROUP_TABLE};
+        """,
     )
     cursor.execute(
-        f"""
+        f"""-- sql
         CREATE TABLE {GROUP_TABLE} (
             id INT NOT NULL AUTO_INCREMENT,
             name VARCHAR(255) NOT NULL,
@@ -134,7 +117,9 @@ def add_group():
         """
     )
     cursor.execute(
-        f"INSERT INTO {GROUP_TABLE} (name, bio) VALUES (%s, %s);",
+        f"""-- sql
+        INSERT INTO {GROUP_TABLE} (name, bio) VALUES (%s, %s);
+        """,
         (tgd.name, tgd.bio),
     )
     db.commit()
@@ -146,10 +131,12 @@ def add_users():
     db = connect_db()
     cursor = db.cursor()
     cursor.execute(
-        f"DROP TABLE IF EXISTS {USER_TABLE};",
+        f"""-- sql
+        DROP TABLE IF EXISTS {USER_TABLE};
+        """,
     )
     cursor.execute(
-        f"""
+        f"""-- sql
         CREATE TABLE {USER_TABLE} (
             id INT NOT NULL AUTO_INCREMENT,
             name VARCHAR(255) NOT NULL,
@@ -161,7 +148,9 @@ def add_users():
     )
     for u in [coco_user, margarite_user, lucas_user, tgd_user, tgd_website]:
         cursor.execute(
-            f"INSERT INTO {USER_TABLE} (name, email, sub) VALUES (%s, %s, %s);",
+            f"""-- sql
+            INSERT INTO {USER_TABLE} (name, email, sub) VALUES (%s, %s, %s);
+            """,
             (u.name, u.email, u.sub),
         )
 
@@ -175,10 +164,12 @@ def add_musicians():
     db = connect_db()
     cursor = db.cursor()
     cursor.execute(
-        f"DROP TABLE IF EXISTS {MUSICIAN_TABLE};",
+        f"""-- sql
+        DROP TABLE IF EXISTS {MUSICIAN_TABLE};
+        """,
     )
     cursor.execute(
-        f"""
+        f"""-- sql
         CREATE TABLE {MUSICIAN_TABLE} (
             id INT NOT NULL AUTO_INCREMENT,
             name VARCHAR(255) NOT NULL,
@@ -190,7 +181,9 @@ def add_musicians():
     )
     for m in [margarite, coco]:
         cursor.execute(
-            f"INSERT INTO {MUSICIAN_TABLE} (name, bio, headshot_id) VALUES (%s, %s, %s);",
+            f"""-- sql
+            INSERT INTO {MUSICIAN_TABLE} (name, bio, headshot_id) VALUES (%s, %s, %s);
+            """,
             (m.name, m.bio, m.headshot_id),
         )
 
@@ -204,13 +197,17 @@ def add_events():
     db = connect_db()
     cursor = db.cursor()
     cursor.execute(
-        f"DROP TABLE IF EXISTS {EVENT_TABLE};",
+        f"""-- sql
+        DROP TABLE IF EXISTS {EVENT_TABLE};
+        """,
     )
     cursor.execute(
-        f"DROP TABLE IF EXISTS {SERIES_TABLE};",
+        f"""-- sql
+        DROP TABLE IF EXISTS {SERIES_TABLE};
+        """,
     )
     cursor.execute(
-        f"""
+        f"""-- sql
         CREATE TABLE {SERIES_TABLE} (
             series_id INT NOT NULL AUTO_INCREMENT,
             name VARCHAR(255) NOT NULL UNIQUE,
@@ -221,7 +218,7 @@ def add_events():
         """
     )
     cursor.execute(
-        f"""
+        f"""-- sql
         CREATE TABLE {EVENT_TABLE} (
             event_id INT NOT NULL AUTO_INCREMENT,
             series_id INT NOT NULL,
@@ -237,7 +234,9 @@ def add_events():
 
     for series in [series1]:
         cursor.execute(
-            f"INSERT INTO {SERIES_TABLE} (name, description, poster_id) VALUES (%s, %s, %s);",
+            f"""-- sql
+            INSERT INTO {SERIES_TABLE} (name, description, poster_id) VALUES (%s, %s, %s);
+            """,
             (
                 series.name,
                 series.description,
@@ -252,7 +251,9 @@ def add_events():
             ticket_url = str(event.ticket_url) if event.ticket_url else None
             map_url = str(event.map_url) if event.map_url else None
             cursor.execute(
-                f"INSERT INTO {EVENT_TABLE} (series_id, location, time, ticket_url, map_url) VALUES (%s, %s, %s, %s, %s);",
+                f"""-- sql
+                INSERT INTO {EVENT_TABLE} (series_id, location, time, ticket_url, map_url) VALUES (%s, %s, %s, %s, %s);
+                """,
                 (
                     series.series_id,
                     event.location,

server/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "thegrapefruitsduo"
-version = "0.4.1"
+version = "0.4.2"
 package-mode = false
 description = "FastAPI backend for thegrapefruitsduo.com"
 authors = ["Lucas Jensen <lucas.p.jensen10@gmail.com>"]

server/tests/controllers/test_event_controller.py

@@ -28,7 +28,7 @@ def test_all_series_with_no_data():
     def no_series() -> list[dict]:
         return []
 
-    mock_queries.select_all_series = no_series
+    mock_queries.select_all = no_series
     result = ec.get_all_series()
     assert result == []
 
@@ -46,7 +46,7 @@ def test_all_series_with_basic_data():
             }
         ]
 
-    mock_queries.select_all_series = one_series_with_no_events
+    mock_queries.select_all = one_series_with_no_events
     result = ec.get_all_series()
     assert isinstance(result, list)
     assert len(result) == 1
@@ -104,7 +104,7 @@ def test_all_series_with_detailed_data():
             row_3,
         ]
 
-    mock_queries.select_all_series = one_series_with_events
+    mock_queries.select_all = one_series_with_events
     result = ec.get_all_series()
     assert isinstance(result, list)
     assert len(result) == 1
@@ -170,7 +170,7 @@ def test_all_series_with_many_series():
             },
         ]
 
-    mock_queries.select_all_series = many_series
+    mock_queries.select_all = many_series
     result = ec.get_all_series()
     assert isinstance(result, list)
     assert len(result) == 3
@@ -195,7 +195,7 @@ def test_all_series_with_error():
             }
         ]
 
-    mock_queries.select_all_series = invalid_series
+    mock_queries.select_all = invalid_series
     with pytest.raises(Exception):
         ec.get_all_series()
         MagicMock.assert_called_once(mock_log_error)

server/tests/controllers/test_musician_controller.py

@@ -50,7 +50,7 @@ def mock_select_one_by_id(musician_id: int):
     return None
 
 
-mock_queries.select_all_series = mock_select_all_series
+mock_queries.select_all = mock_select_all_series
 mock_queries.select_one_by_id = mock_select_one_by_id
 
 
@@ -85,10 +85,10 @@ def test_happy_get_musicians():
 
 
 def test_sad_get_musicians():
-    mock_queries.select_all_series = mock_select_all_series_sad
+    mock_queries.select_all = mock_select_all_series_sad
     with pytest.raises(HTTPException) as e:
         mc.get_musicians()
-    mock_queries.select_all_series = mock_select_all_series
+    mock_queries.select_all = mock_select_all_series
     assert isinstance(e.value, HTTPException)
     assert e.value.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
 

server/tests/controllers/test_user_controller.py

@@ -60,7 +60,7 @@ def test_type():
 
 def test_get_users():
     """Tests the retrieval of users from the database."""
-    mock_queries.select_all_series.return_value = valid_user_data
+    mock_queries.select_all.return_value = valid_user_data
     users = uc.get_users()
     assert isinstance(users, list)
     assert len(users) == 2
@@ -85,7 +85,7 @@ def test_get_users():
 
 def test_get_users_sad():
     """Tests the retrieval of users from the database with invalid data."""
-    mock_queries.select_all_series.return_value = invalid_user_data
+    mock_queries.select_all.return_value = invalid_user_data
     with pytest.raises(HTTPException) as e:
         uc.get_users()
     assert isinstance(e.value, HTTPException)