refactor endpoint request handling

Author: summerduck

conftest.py

@@ -68,45 +68,58 @@ def start_testing(
 
 @pytest.fixture(scope="session")
 def generate_api_token():
-    base_url = "http://167.172.172.115:52355"
+    logger.info("Verifying API token")
+
+    # Get the environment variables
+    base_url = os.getenv("BASE_URL")
     token = os.getenv("API_TOKEN")
-    logger.info("Getting API token. Current token: %s", token)
+    user_name = os.getenv("USER_NAME")
 
     # Verify that the token is valid
     post_authorize_verify_url = f"{base_url}/authorize/{token}"
-    logger.info("Verifying token: %s", post_authorize_verify_url)
     response = requests.get(post_authorize_verify_url)
     if response.status_code != 200:
         # If the token is not valid, get a new one
-        logger.info("Token is not valid. Getting a new one")
+        logger.info("API token is not valid. Getting a new one")
         post_authorize_url = f"{base_url}/authorize"
         response = requests.post(
             post_authorize_url,
-            json={"name": "Summerduck"},
+            json={"name": user_name},
         )
         assert response.status_code == 200
         token = response.json()["token"]
-        os.environ["API_TOKEN"] = token
         set_key(
             dotenv_path=find_dotenv(),
             key_to_set="API_TOKEN",
             value_to_set=token,
         )
+        logger.info("API token has been updated")
 
-    logger.info(f"Token: {token}")
+    logger.info("API token is valid")
 
     yield token
 
-    logger.info("Deleting API token")
-
 
-# TODO: Implement the clean_up fixture
 @pytest.fixture(scope="function")
-def clean_up(post_meme, delete_meme):
+def temporary_meme_cleanup(post_meme, delete_meme):
     yield
-    logger.info("Cleaning up")
-    meme_id = post_meme.receive_post_meme_id()
-    delete_meme.delete_meme_by_id(meme_id)
+    id = post_meme.meme_id
+    logger.info(
+        "------------ TearDown: Deleting the meme that was created: %s ------------", id
+    )
+    delete_meme.delete_meme_by_id(id)
+    logger.info("------------ TearDown: Meme has been deleted ------------")
+
+
+@pytest.fixture(scope="function")
+def temporary_meme_id(post_meme):
+    logger.info("------------ SetUp: Creating a new meme ------------")
+    response = post_meme.post_new_meme()
+    logger.info(
+        "------------ SetUp: Created a new meme with id: %s ------------ ",
+        response.json()["id"],
+    )
+    yield response.json()["id"]
 
 
 def __make_dir_for_logs():
@@ -164,19 +177,6 @@ def pytest_runtest_setup(item):
     logger.info(f"Starting test - {item.nodeid}")
 
 
-@pytest.hookimpl(tryfirst=True)
-def pytest_runtest_teardown(item, nextitem):
-    """leans up the logger after the test is completed"""
-    logger = logging.getLogger()
-    logger.info(f"Finished test - {item.nodeid}")
-
-    # Remove test-specific handlers
-    for handler in logger.handlers[:]:
-        if isinstance(handler, logging.FileHandler):
-            handler.close()
-            logger.removeHandler(handler)
-
-
 @pytest.hookimpl(tryfirst=True)
 def pytest_runtest_logreport(report):
     """Handles special processing for logs of failed tests"""

data/base_meme.py

@@ -3,3 +3,98 @@ class BaseMemeData:
         ({"Authorization": "invalid"}, 401),
         ({"Authorization": ""}, 500),
     ]
+
+    memes_not_existing_ids = [
+        (9999999999999),
+        ("string"),
+        ([]),
+        ({}),
+        (None),
+        (True),
+        (False),
+        (0.123456789),
+        (-1),
+        (0),
+        (3.14159),
+        ({"key": "value"}),
+        (["list", "of", "strings"]),
+    ]
+
+    #  "text": "string"
+    invalid_text = [
+        # Non-string data types
+        123,
+        123.45,
+        True,
+        False,
+        None,
+        [1, 2, 3],
+        {"key": "value"},
+        # Empty or whitespace strings
+        "",
+        "   ",
+        # # Boundary conditions
+        # "a" * XX,  # Assuming max length is XX
+        # "a" * X,  # Assuming min length is X
+        # Edge cases
+        "\n",
+        "\t",
+        "\r",
+    ]
+
+    # "tags": ["string", "string"]
+    invalid_tags = [
+        # Non-array data types
+        "justastring",
+        123,
+        123.45,
+        True,
+        False,
+        None,
+        {"key": "value"},
+        # Invalid array structures
+        [],
+        [123, True, None, ["nestedArray"]],
+        ["valid", 123, True],
+        [["nested", "array"]],
+        [{"key": "value"}],
+        # Invalid content in tags
+        ["", "   "],
+        ["@#$%^&*()"],
+        ["DROP TABLE tags;"],
+        ["<script>alert('XSS')</script>"],
+        ["\xC0"],
+        ["a" * 10001],  # Assuming max tag length = ???
+        # Boundary conditions
+        ["tag" + str(i) for i in range(1000)],  # Assuming max tags = ???
+        # Edge cases
+        ["\n", "\t", "\r"],
+        ["duplicate", "duplicate"],
+    ]
+
+    # "info": { "key": "value" }
+    invalid_info = [
+        # Non-object data types
+        "justastring",
+        ["key", "value"],
+        123,
+        123.45,
+        True,
+        False,
+        None,
+        # Invalid object structures
+        {},
+        {123: "value", True: "value"},
+        {"key": None, "key2": 123},
+        {"key": {"nestedKey": "nestedValue"}},
+        # Invalid key-value content
+        {"": "value", "key": ""},
+        {"a" * 10001: "value", "key": "b" * 10001},
+        # Boundary conditions
+        {f"key{i}": f"value{i}" for i in range(1000)},  # Assuming max keys = ???
+        {"a" * 51: "value", "key": "b" * 51},  # Assuming max length = ???
+        # Edge cases
+        {" key ": " value "},
+        {"\nkey": "value", "key": "\tvalue"},
+        {"key": "value1", "key": "value2"},
+    ]

data/get_meme.py

@@ -3,23 +3,3 @@ class GetMemeData:
         (1),
         (5),
     ]
-
-    memes_not_existing_ids = [
-        (9999999999999),
-        ("string"),
-        ([]),
-        ({}),
-        (None),
-        (True),
-        (False),
-        (0.123456789),
-        (-1),
-        (0),
-        (3.14159),
-        ({"key": "value"}),
-        (["list", "of", "strings"]),
-        (set([1, 2, 3])),
-        (frozenset([4, 5, 6])),
-        (bytearray(b"byte array")),
-        (complex(1, 2)),
-    ]

endpoints/base_endpoint.py

@@ -110,3 +110,4 @@ def verify_response_status_code(
             f"Expected status code {status_code},"
             f"but got {self.response.status_code}"
         )
+    

endpoints/post_meme.py

@@ -21,14 +21,16 @@ def post_new_meme(
         tags: Optional[list] = None,
         info: Optional[dict] = None,
         headers: Optional[dict] = None,
+        json: Optional[dict] = None,
     ) -> requests.Response:
         """Make a POST request to the /meme endpoint"""
-        json = {
-            "text": text or self._generate_text(),
-            "url": url or self._generate_url(),
-            "tags": tags or self._generate_tags(),
-            "info": info or self._generate_picture_info(),
-        }
+        if json is None:
+            json = {
+                "text": text or self._generate_text(),
+                "url": url or self._generate_url(),
+                "tags": tags or self._generate_tags(),
+                "info": info or self._generate_picture_info(),
+            }
 
         self.response = self._send_request(
             "POST",

endpoints/put_meme.py

@@ -22,19 +22,21 @@ def put_meme_by_id(
         tags: Optional[list] = None,
         info: Optional[dict] = None,
         headers: Optional[dict] = None,
+        json: Optional[dict] = None,
     ) -> requests.Response:
         """Make a POST request to the /meme endpoint"""
-        json = {
-            "id": id,
-            "text": text or self._generate_text(),
-            "url": url or self._generate_url(),
-            "tags": tags or self._generate_tags(),
-            "info": info or self._generate_picture_info(),
-        }
+        if json is None:
+            json = {
+                "id": id,
+                "text": text or self._generate_text(),
+                "url": url or self._generate_url(),
+                "tags": tags or self._generate_tags(),
+                "info": info or self._generate_picture_info(),
+            }
 
         self.response = self._send_request(
-            "POST",
-            "/meme",
+            "PUT",
+            f"/meme/{id}",
             headers=headers,
             json=json,
         )

pytest.ini

@@ -4,10 +4,11 @@ python_files = test_*
 python_classes = *Test
 python_functions = test_*
 log_cli = true
+log_cli_level = INFO
 log_level = INFO
 markers =
     delete_meme
     positive
     negative
 
-addopts = -v -s --alluredir=test-report
+addopts = --alluredir=test-report

rlogger.py

@@ -19,25 +19,26 @@ def filter(self, record):
 logger.addFilter(FunctionNameFilter())
 
 
-def requests_logging(request: Request):
+def requests_logging(request: Request, endpoint: str):
     # Map the request method to the corresponding logging level
-    extra = {"func_name": request.method}
+    extra = {"func_name": f"{request.method} {endpoint}"}
 
     # Log the request data
-    logger.info(
-        f"Request data: {request.data}",
-        extra=extra,
-    )
     logger.info(
         f"Request method: {request.method}",
         extra=extra,
     )
     logger.info(
-        f"Request URL: {request.url}",
+        f"Request url: {request.url}",
         extra=extra,
     )
+
+    # Do not show token in logs
+    headers = dict(request.headers)
+    if "Authorization" in headers:
+        headers["Authorization"] = "***SECRET***"
     logger.info(
-        f"Request headers: {json.dumps(dict(request.headers), indent=2)}",
+        f"Request headers: {headers}",
         extra=extra,
     )
     try:
@@ -48,24 +49,27 @@ def requests_logging(request: Request):
         )
     except TypeError:
         logger.info(
-            "'Request' object has no attribute 'body'",
+            "Request object has no attribute body",
             extra=extra,
         )
 
 
-def response_logging(response: Response):
+def response_logging(response: Response, endpoint: str):
+    # Map the request method to the corresponding logging level
+    extra = {"func_name": f"{response.request.method} {endpoint}"}
+
     logger.info(
         f"Response status code: {response.status_code}",
-        extra={"func_name": response.request.method},
+        extra=extra,
     )
     try:
         response_content = response.json()
         logger.info(
             f"Response content: {json.dumps(response_content, indent=2)}",
-            extra={"func_name": response.request.method},
+            extra=extra,
         )
     except ValueError:
         logger.info(
-            f"Response content is not in JSON format: {response.text}",
-            extra={"func_name": response.request.method},
+            f"Response content: {response.text}",
+            extra=extra,
         )