devranta/test.py

import json
import uuid
from datetime import datetime
from typing import Any, Dict, List, Optional

import requests

# Configuration
BASE_URL: str = "https://devrant.com/api"
RESULTS_FILE: str = "api_test_results.json"
APP: int = 3
PLAT: int = 3
GUID: str = str(uuid.uuid4())
SID: str = str(int(datetime.now().timestamp()))
SEID: str = str(uuid.uuid4())

# Real credentials for login (using provided username/email and password)
LOGIN_USERNAME: str = "power-to@the-puff.com"
LOGIN_PASSWORD: str = "powerpuffgirl"

# Variables to store auth after login
AUTH_TOKEN_ID: Optional[str] = None
AUTH_TOKEN_KEY: Optional[str] = None
AUTH_USER_ID: Optional[str] = None

# Mock/fallback values (overridden after login or fetch)
TEST_EMAIL: str = "test@example.com"
TEST_USERNAME: str = "testuser" + str(
    int(datetime.now().timestamp())
)  # Make unique for registration
TEST_PASSWORD: str = "Test1234!"
TEST_RANT_ID: str = "1"  # Will be overridden with real one
TEST_COMMENT_ID: str = "1"  # Will be overridden with real one
TEST_NEWS_ID: str = "1"  # Assuming this might work; adjust if needed

# Initialize results
results: List[Dict[str, Any]] = []


def save_results() -> None:
    """Save the accumulated test results to JSON file."""
    with open(RESULTS_FILE, "w") as f:
        json.dump(results, f, indent=2)


def test_endpoint(
    method: str,
    url: str,
    params: Optional[Dict[str, Any]] = None,
    data: Optional[Dict[str, Any]] = None,
    files: Optional[Dict[str, Any]] = None,
    headers: Optional[Dict[str, str]] = None,
) -> Dict[str, Any]:
    """
    Execute an API request and record the result.

    Payload:
    - method: HTTP method (GET, POST, DELETE, etc.)
    - url: Full API URL
    - params: Query parameters (dict)
    - data: POST/PUT body (dict)
    - files: Multipart files (dict)
    - headers: Custom headers (dict)

    Response:
    - Returns a dict with url, method, status_code, response (JSON or error), headers, request_body, timestamp
    """
    try:
        response = requests.request(
            method, url, params=params, data=data, files=files, headers=headers
        )
        result: Dict[str, Any] = {
            "url": response.url,
            "method": method,
            "status_code": response.status_code,
            "response": response.json() if response.content else {},
            "headers": dict(response.headers),
            "request_body": data or params or {},
            "timestamp": datetime.now().isoformat(),
        }
        results.append(result)
        return result
    except Exception as e:
        result: Dict[str, Any] = {
            "url": url,
            "method": method,
            "status_code": None,
            "response": {"error": str(e)},
            "headers": {},
            "request_body": data or params or {},
            "timestamp": datetime.now().isoformat(),
        }
        results.append(result)
        return result


# Helper to patch auth into params/data
def patch_auth(base_dict: Dict[str, Any]) -> Dict[str, Any]:
    """
    Add authentication to request dict if available.

    Payload: base_dict (params or data)
    Response: Updated dict with app, user_id, token_id, token_key if auth present
    """
    auth_dict: Dict[str, Any] = {"app": APP}
    if AUTH_USER_ID and AUTH_TOKEN_ID and AUTH_TOKEN_KEY:
        auth_dict.update(
            {
                "user_id": AUTH_USER_ID,
                "token_id": AUTH_TOKEN_ID,
                "token_key": AUTH_TOKEN_KEY,
            }
        )
    base_dict.update(auth_dict)
    return base_dict


# Login function to get real auth tokens
def login_user() -> bool:
    """
    Perform login to obtain real auth tokens.

    Payload: POST to /users/auth-token with username, password, app
    Response: success (bool), sets global AUTH_* variables on success
    """
    params: Dict[str, Any] = {
        "username": LOGIN_USERNAME,
        "password": LOGIN_PASSWORD,
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    result = test_endpoint(
        "POST", f"{BASE_URL}/users/auth-token", data=patch_auth(params)
    )
    if result["status_code"] == 200 and result.get("response", {}).get("success"):
        auth_token = result["response"].get("auth_token", {})
        global AUTH_USER_ID, AUTH_TOKEN_ID, AUTH_TOKEN_KEY
        AUTH_USER_ID = str(auth_token.get("user_id", ""))
        AUTH_TOKEN_ID = str(auth_token.get("id", ""))
        AUTH_TOKEN_KEY = auth_token.get("key", "")
        return True
    return False


# Fetch a real rant_id from feed
def fetch_real_rant_id() -> Optional[str]:
    """
    Fetch rants feed to get a real rant_id.

    Payload: GET to /devrant/rants with auth
    Response: First rant_id if success, else None
    """
    params: Dict[str, Any] = {"plat": PLAT, "guid": GUID, "sid": SID, "seid": SEID}
    result = test_endpoint(
        "GET", f"{BASE_URL}/devrant/rants", params=patch_auth(params)
    )
    if result["status_code"] == 200 and result.get("response", {}).get("success"):
        rants = result["response"].get("rants", [])
        if rants:
            return str(rants[0]["id"])
    return None


# Post a test rant and return its id
def post_test_rant() -> Optional[str]:
    """
    Post a test rant to get a real rant_id for further tests.

    Payload: POST to /devrant/rants with rant content, tags, auth
    Response: rant_id if success, else None
    """
    data: Dict[str, Any] = {
        "rant": "Test rant for API testing (ignore)",
        "tags": "test,api",
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    result = test_endpoint("POST", f"{BASE_URL}/devrant/rants", data=patch_auth(data))
    if result["status_code"] == 200 and result.get("response", {}).get("success"):
        return str(result["response"].get("rant_id", ""))
    return None


# Post a test comment and return its id
def post_test_comment(rant_id: str) -> Optional[str]:
    """
    Post a test comment to get a real comment_id.

    Payload: POST to /devrant/rants/{rant_id}/comments with comment, auth
    Response: comment_id if success, else None
    """
    data: Dict[str, Any] = {
        "comment": "Test comment for API testing (ignore)",
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    result = test_endpoint(
        "POST", f"{BASE_URL}/devrant/rants/{rant_id}/comments", data=patch_auth(data)
    )
    if result["status_code"] == 200 and result.get("response", {}).get("success"):
        return str(result["response"].get("comment_id", ""))
    return None


# Test cases with docstrings


def test_register_user() -> None:
    """
    Test user registration (valid and invalid).

    Payload (valid): POST /users with email, username, password, type=1, plat, guid, sid, seid, app
    Expected: success=true if unique, else error

    Payload (invalid): Missing email
    Expected: error on email field
    """
    params: Dict[str, Any] = {
        "type": 1,
        "email": TEST_EMAIL,
        "username": TEST_USERNAME,
        "password": TEST_PASSWORD,
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    test_endpoint("POST", f"{BASE_URL}/users", data=patch_auth(params.copy()))
    invalid_params = params.copy()
    del invalid_params["email"]
    test_endpoint("POST", f"{BASE_URL}/users", data=patch_auth(invalid_params))


def test_login_user() -> None:
    """
    Test user login (valid and invalid). Already done in login_user(), but record here.

    Payload (valid): POST /users/auth-token with username, password, plat, guid, sid, seid, app
    Expected: success=true, auth_token

    Payload (invalid): Wrong password
    Expected: error=Invalid login credentials
    """
    # Valid is handled in login_user(); here test invalid
    params: Dict[str, Any] = {
        "username": TEST_USERNAME,
        "password": "WrongPass",
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    test_endpoint("POST", f"{BASE_URL}/users/auth-token", data=patch_auth(params))


def test_edit_profile() -> None:
    """
    Test editing user profile.

    Payload: POST /users/me/edit-profile with profile fields, plat, guid, sid, seid, auth
    Expected: success=true
    """
    params: Dict[str, Any] = {
        "profile_about": "Test bio",
        "profile_skills": "Python, JS",
        "profile_location": "Test City",
        "profile_website": "http://example.com",
        "profile_github": "testuser",
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    test_endpoint("POST", f"{BASE_URL}/users/me/edit-profile", data=patch_auth(params))


def test_forgot_password() -> None:
    """
    Test forgot password.

    Payload: POST /users/forgot-password with username, plat, guid, sid, seid, app
    Expected: success=true (even without auth)
    """
    params: Dict[str, Any] = {
        "username": LOGIN_USERNAME,  # Use real one
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    test_endpoint("POST", f"{BASE_URL}/users/forgot-password", data=patch_auth(params))


def test_resend_confirm() -> None:
    """
    Test resend confirmation email.

    Payload: POST /users/me/resend-confirm with plat, guid, sid, seid, auth
    Expected: success=true
    """
    params: Dict[str, Any] = {"plat": PLAT, "guid": GUID, "sid": SID, "seid": SEID}
    test_endpoint(
        "POST", f"{BASE_URL}/users/me/resend-confirm", data=patch_auth(params)
    )


def test_delete_account() -> None:
    """
    Test delete account (caution: irreversible).

    Payload: DELETE /users/me with plat, guid, sid, seid, auth
    Expected: success=true
    """
    # Comment out to avoid accidental deletion
    # params: Dict[str, Any] = {
    #     "plat": PLAT,
    #     "guid": GUID,
    #     "sid": SID,
    #     "seid": SEID
    # }
    # test_endpoint("DELETE", f"{BASE_URL}/users/me", params=patch_auth(params))
    pass


def test_mark_news_read() -> None:
    """
    Test mark news as read.

    Payload: POST /users/me/mark-news-read with news_id, plat, guid, sid, seid, auth
    Expected: success=true
    """
    params: Dict[str, Any] = {
        "news_id": TEST_NEWS_ID,
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    test_endpoint(
        "POST", f"{BASE_URL}/users/me/mark-news-read", data=patch_auth(params)
    )


def test_get_rant() -> None:
    """
    Test get single rant.

    Payload: GET /devrant/rants/{rant_id} with last_comment_id, links, plat, guid, sid, seid, auth
    Expected: success=true, rant details
    """
    params: Dict[str, Any] = {
        "last_comment_id": "999999999999",
        "links": 0,
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    test_endpoint(
        "GET", f"{BASE_URL}/devrant/rants/{TEST_RANT_ID}", params=patch_auth(params)
    )


def test_post_rant() -> None:
    """
    Test post new rant. (Already done in post_test_rant for id)

    Payload: POST /devrant/rants with rant, tags, auth
    Expected: success=true, rant_id
    """
    # Handled in setup
    pass


def test_edit_rant() -> None:
    """
    Test edit rant.

    Payload: POST /devrant/rants/{rant_id} with updated rant, tags, auth
    Expected: success=true
    """
    data: Dict[str, Any] = {"rant": "Updated test rant", "tags": "test,python,update"}
    test_endpoint(
        "POST", f"{BASE_URL}/devrant/rants/{TEST_RANT_ID}", data=patch_auth(data)
    )


def test_delete_rant() -> None:
    """
    Test delete rant.

    Payload: DELETE /devrant/rants/{rant_id} with plat, guid, sid, seid, auth
    Expected: success=true
    """
    params: Dict[str, Any] = {"plat": PLAT, "guid": GUID, "sid": SID, "seid": SEID}
    test_endpoint(
        "DELETE", f"{BASE_URL}/devrant/rants/{TEST_RANT_ID}", params=patch_auth(params)
    )


def test_vote_rant() -> None:
    """
    Test vote on rant (upvote and downvote with reason).

    Payload: POST /devrant/rants/{rant_id}/vote with vote (1/-1), reason (optional), plat, guid, sid, seid, auth
    Expected: success=true
    """
    params: Dict[str, Any] = {
        "vote": 1,
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    test_endpoint(
        "POST", f"{BASE_URL}/devrant/rants/{TEST_RANT_ID}/vote", data=patch_auth(params)
    )
    params["vote"] = -1
    params["reason"] = "1"
    test_endpoint(
        "POST", f"{BASE_URL}/devrant/rants/{TEST_RANT_ID}/vote", data=patch_auth(params)
    )


def test_favorite_rant() -> None:
    """
    Test favorite/unfavorite rant.

    Payload: POST /devrant/rants/{rant_id}/favorite or /unfavorite with plat, guid, sid, seid, auth
    Expected: success=true
    """
    params: Dict[str, Any] = {"plat": PLAT, "guid": GUID, "sid": SID, "seid": SEID}
    test_endpoint(
        "POST",
        f"{BASE_URL}/devrant/rants/{TEST_RANT_ID}/favorite",
        data=patch_auth(params),
    )
    test_endpoint(
        "POST",
        f"{BASE_URL}/devrant/rants/{TEST_RANT_ID}/unfavorite",
        data=patch_auth(params),
    )


def test_get_rant_feed() -> None:
    """
    Test get rant feed.

    Payload: GET /devrant/rants with plat, guid, sid, seid, auth
    Expected: success=true, list of rants
    """
    params: Dict[str, Any] = {"plat": PLAT, "guid": GUID, "sid": SID, "seid": SEID}
    test_endpoint("GET", f"{BASE_URL}/devrant/rants", params=patch_auth(params))


def test_get_comment() -> None:
    """
    Test get single comment.

    Payload: GET /comments/{comment_id} with links, plat, guid, sid, seid, auth
    Expected: success=true, comment details
    """
    params: Dict[str, Any] = {
        "links": 0,
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    test_endpoint(
        "GET", f"{BASE_URL}/comments/{TEST_COMMENT_ID}", params=patch_auth(params)
    )


def test_post_comment() -> None:
    """
    Test post comment. (Handled in post_test_comment for id)

    Payload: POST /devrant/rants/{rant_id}/comments with comment, auth
    Expected: success=true, comment_id
    """
    # Handled in setup
    pass


def test_edit_comment() -> None:
    """
    Test edit comment.

    Payload: POST /comments/{comment_id} with updated comment, auth
    Expected: success=true
    """
    data: Dict[str, Any] = {"comment": "Updated test comment"}
    test_endpoint(
        "POST", f"{BASE_URL}/comments/{TEST_COMMENT_ID}", data=patch_auth(data)
    )


def test_delete_comment() -> None:
    """
    Test delete comment.

    Payload: DELETE /comments/{comment_id} with plat, guid, sid, seid, auth
    Expected: success=true
    """
    params: Dict[str, Any] = {"plat": PLAT, "guid": GUID, "sid": SID, "seid": SEID}
    test_endpoint(
        "DELETE", f"{BASE_URL}/comments/{TEST_COMMENT_ID}", params=patch_auth(params)
    )


def test_vote_comment() -> None:
    """
    Test vote on comment.

    Payload: POST /comments/{comment_id}/vote with vote (1), plat, guid, sid, seid, auth
    Expected: success=true
    """
    params: Dict[str, Any] = {
        "vote": 1,
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    test_endpoint(
        "POST", f"{BASE_URL}/comments/{TEST_COMMENT_ID}/vote", data=patch_auth(params)
    )


def test_get_notif_feed() -> None:
    """
    Test get notification feed.

    Payload: GET /users/me/notif-feed with ext_prof, last_time, plat, guid, sid, seid, auth
    Expected: success=true, notifications
    """
    params: Dict[str, Any] = {
        "ext_prof": 1,
        "last_time": str(int(datetime.now().timestamp())),
        "plat": PLAT,
        "guid": GUID,
        "sid": SID,
        "seid": SEID,
    }
    test_endpoint("GET", f"{BASE_URL}/users/me/notif-feed", params=patch_auth(params))


def test_clear_notifications() -> None:
    """
    Test clear notifications.

    Payload: DELETE /users/me/notif-feed with plat, guid, sid, seid, auth
    Expected: success=true
    """
    params: Dict[str, Any] = {"plat": PLAT, "guid": GUID, "sid": SID, "seid": SEID}
    test_endpoint(
        "DELETE", f"{BASE_URL}/users/me/notif-feed", params=patch_auth(params)
    )


def test_beta_list_signup() -> None:
    """
    Test beta list signup (external API).

    Payload: GET https://www.hexicallabs.com/api/beta-list with email, platform, app
    Expected: Whatever the API returns (may not be JSON)
    """
    params: Dict[str, Any] = {"email": TEST_EMAIL, "platform": "test_platform"}
    test_endpoint(
        "GET", "https://www.hexicallabs.com/api/beta-list", params=patch_auth(params)
    )


def main() -> None:
    # Setup: Login and fetch real IDs
    if login_user():
        global TEST_RANT_ID
        TEST_RANT_ID = post_test_rant() or fetch_real_rant_id() or "1"
        global TEST_COMMENT_ID
        TEST_COMMENT_ID = post_test_comment(TEST_RANT_ID) or "1"

    test_register_user()
    test_login_user()
    test_edit_profile()
    test_forgot_password()
    test_resend_confirm()
    test_mark_news_read()
    test_get_rant()
    test_post_rant()
    test_edit_rant()
    test_vote_rant()
    test_favorite_rant()
    test_get_rant_feed()
    test_get_comment()
    test_post_comment()
    test_edit_comment()
    test_delete_comment()
    test_vote_comment()
    test_get_notif_feed()
    test_clear_notifications()
    test_beta_list_signup()
    test_delete_rant()

    test_delete_account()
    save_results()


if __name__ == "__main__":
    main()