Untitled

import pytest
from fastapi.testclient import TestClient
from fastapi import HTTPException
from src.routes import router
from src.dependables import db, verify_admin_token, maintenance
from src.database.dbutils import is_db_locked, lock_db, unlock_db
from unittest.mock import Mock, MagicMock, patch
from pytest import MonkeyPatch

# Create a TestClient instance for the router
client = TestClient(router)

def test_login_endpoint():
    response = client.get("/login")
    assert response.status_code == 302  # Redirect to authorization URL

def test_authcallback_endpoint():
    # Mocking the OAuth flow is complex; this is a simplified example.
    # In real tests, you might need to mock out more dependencies.
    with patch("src.routes.oauth.pingfed.authorize_access_token", return_value={
        "access_token": "mock_access_token",
        "id_token": "mock_id_token",
        "refresh_token": "mock_refresh_token"
    }):
        response = client.get("/authcallback")
        assert response.status_code == 307  # Temporary redirect

def test_logout_endpoint():
    # Test successful logout
    headers = {
        "Authorization": "Bearer mock_access_token",
        "ID-Token": "Bearer mock_id_token"
    }
    with patch("src.routes.remove_token_from_cache") as mock_remove_token:
        response = client.get("/logout", headers=headers)
        assert response.status_code == 200
        assert response.json() == {"message": "You are successfully logged out"}
        mock_remove_token.assert_called_once()

    # Test invalid authorization scheme
    headers = {
        "Authorization": "Invalid mock_access_token"
    }
    response = client.get("/logout", headers=headers)
    assert response.status_code == 200
    assert response.json() == {"message": "Invalid Authorization Scheme"}

def test_upgrade_endpoint(mock_db_session, monkeypatch):
    monkeypatch.setenv('MIDDLEWARE_SESSION_KEY', 'valid_session_key')

    # Mocking the admin token verification and database session
    with patch("src.dependables.verify_admin_token", return_value=None):
        with patch("src.routes.db", return_value=mock_db_session):
            with patch("alembic.command.upgrade") as mock_upgrade:
                response = client.get("/upgrade")
                assert response.status_code == 200  # Assuming no exceptions are raised

                # Check if lock_db and unlock_db were called
                lock_db.assert_called_once_with(mock_db_session)
                unlock_db.assert_called_once_with(mock_db_session)
                mock_upgrade.assert_called_once()

def test_upgrade_endpoint_db_locked(mock_db_session, monkeypatch):
    monkeypatch.setenv('MIDDLEWARE_SESSION_KEY', 'valid_session_key')

    # Mocking the admin token verification and database session
    with patch("src.dependables.verify_admin_token", return_value=None):
        with patch("src.routes.db", return_value=mock_db_session):
            with patch("src.database.dbutils.is_db_locked", return_value=True):
                with pytest.raises(HTTPException) as exc_info:
                    client.get("/upgrade")
                assert exc_info.value.status_code == 503

def test_vars_endpoint(mock_db_session, monkeypatch):
    monkeypatch.setenv('MIDDLEWARE_SESSION_KEY', 'valid_session_key')

    # Mocking the admin token verification and database session
    with patch("src.dependables.verify_admin_token", return_value=None):
        with patch("src.routes.db", return_value=mock_db_session):
            response = client.get("/vars")
            assert response.status_code == 200  # Assuming no exceptions are raised

def test_clear_cache_endpoint(mock_db_session, monkeypatch):
    monkeypatch.setenv('MIDDLEWARE_SESSION_KEY', 'valid_session_key')

    # Mocking the admin token verification and database session
    with patch("src.dependables.verify_admin_token", return_value=None):
        with patch("src.routes.db", return_value=mock_db_session):
            with patch("src.routes.clear_token_cache") as mock_clear_cache:
                response = client.get("/cache")
                assert response.status_code == 200  # Assuming no exceptions are raised
                mock_clear_cache.assert_called_once()

# Helper fixtures for mocking sessions
@pytest.fixture
def mock_db_session():
    db_session = MagicMock()
    db_session.scalar.return_value = db_session
    db_session.is_db_locked = False
    return db_session

@pytest.fixture
def monkeypatch():
    return MonkeyPatch()




# Create a TestClient instance for the router
client = TestClient(router)

def test_login_endpoint():
    response = client.get("/login")
    assert response.status_code == 302  # Redirect to authorization URL

def test_authcallback_endpoint():
    # Mocking the OAuth flow is complex; this is a simplified example.
    # In real tests, you might need to mock out more dependencies.
    with patch("src.routes.oauth.pingfed.authorize_access_token", return_value={
        "access_token": "mock_access_token",
        "id_token": "mock_id_token",
        "refresh_token": "mock_refresh_token"
    }):
        response = client.get("/authcallback")
        assert response.status_code == 307  # Temporary redirect

def test_logout_endpoint():
    # Test successful logout
    headers = {
        "Authorization": "Bearer mock_access_token",
        "ID-Token": "Bearer mock_id_token"
    }
    with patch("src.routes.remove_token_from_cache") as mock_remove_token:
        response = client.get("/logout", headers=headers)
        assert response.status_code == 200
        assert response.json() == {"message": "You are successfully logged out"}
        mock_remove_token.assert_called_once()

    # Test invalid authorization scheme
    headers = {
        "Authorization": "Invalid mock_access_token"
    }
    response = client.get("/logout", headers=headers)
    assert response.status_code == 200
    assert response.json() == {"message": "Invalid Authorization Scheme"}

    # Test no authorization header
    response = client.get("/logout")
    assert response.status_code == 200
    assert response.json() == {"message": "You are not logged in"}

def test_upgrade_endpoint(mock_db_session, monkeypatch):
    monkeypatch.setenv('MIDDLEWARE_SESSION_KEY', 'valid_session_key')

    # Mocking the admin token verification and database session
    with patch("src.dependables.verify_admin_token", return_value=None):
        with patch("src.routes.db", return_value=mock_db_session):
            with patch("alembic.command.upgrade") as mock_upgrade:
                response = client.get("/upgrade")
                assert response.status_code == 200  # Assuming no exceptions are raised

                # Check if lock_db and unlock_db were called
                lock_db.assert_called_once_with(mock_db_session)
                unlock_db.assert_called_once_with(mock_db_session)
                mock_upgrade.assert_called_once()

def test_upgrade_endpoint_db_locked(mock_db_session, monkeypatch):
    monkeypatch.setenv('MIDDLEWARE_SESSION_KEY', 'valid_session_key')

    # Mocking the admin token verification and database session
    with patch("src.dependables.verify_admin_token", return_value=None):
        with patch("src.routes.db", return_value=mock_db_session):
            with patch("src.database.dbutils.is_db_locked", return_value=True):
                with pytest.raises(HTTPException) as exc_info:
                    client.get("/upgrade")
                assert exc_info.value.status_code == 503

def test_upgrade_endpoint_exception(mock_db_session, monkeypatch):
    monkeypatch.setenv('MIDDLEWARE_SESSION_KEY', 'valid_session_key')

    # Mocking the admin token verification and database session
    with patch("src.dependables.verify_admin_token", return_value=None):
        with patch("src.routes.db", return_value=mock_db_session):
            with patch("alembic.command.upgrade", side_effect=Exception("Mocked Exception")):
                with pytest.raises(HTTPException) as exc_info:
                    client.get("/upgrade")
                assert exc_info.value.status_code == 500

def test_vars_endpoint(mock_db_session, monkeypatch):
    monkeypatch.setenv('MIDDLEWARE_SESSION_KEY', 'valid_session_key')

    # Mocking the admin token verification and database session
    with patch("src.dependables.verify_admin_token", return_value=None):
        with patch("src.routes.db", return_value=mock_db_session):
            response = client.get("/vars")
            assert response.status_code == 200  # Assuming no exceptions are raised

def test_vars_endpoint_exception(mock_db_session, monkeypatch):
    monkeypatch.setenv('MIDDLEWARE_SESSION_KEY', 'valid_session_key')

    # Mocking the







def test_login_endpoint_success():
    # Successful redirect to authorization URL
    response = client.get("/login")
    assert response.status_code == 302  # Redirect status code
    assert "Location" in response.headers  # Check if Location header is present

def test_login_endpoint_invalid_authorization_url(mock_env_vars):
    # Mock invalid authorization URL
    mock_env_vars("AUTHORIZATION_ENDPOINT", None)

    with pytest.raises(HTTPException) as exc_info:
        client.get("/login")

    assert exc_info.value.status_code == 500  # Internal Server Error

def test_login_endpoint_invalid_redirect_uri(mock_env_vars):
    # Mock invalid redirect URI
    mock_env_vars("AUTHCALLBACK_REDIRECT_URI", None)

    with pytest.raises(HTTPException) as exc_info:
        client.get("/login")

    assert exc_info.value.status_code == 500  # Internal Server Error

def test_login_endpoint_oauth_error(mock_oauth_authorize_redirect):
    # Mock OAuth error during authorization redirect
    mock_oauth_authorize_redirect(side_effect=Exception("Mocked OAuth Error"))

    with pytest.raises(HTTPException) as exc_info:
        client.get("/login")

    assert exc_info.value.status_code == 500  # Internal Server Error

def test_login_endpoint_other_errors(mock_oauth_authorize_redirect):
    # Mock other errors during authorization redirect
    mock_oauth_authorize_redirect(side_effect=RuntimeError("Mocked Runtime Error"))

    with pytest.raises(HTTPException) as exc_info:
        client.get("/login")

    assert exc_info.value.status_code == 500  # Internal Server Error

# Helper fixtures for mocking environment variables and OAuth functions

@pytest.fixture
def mock_env_vars(monkeypatch):
    def _mock_env_vars(var_name, value):
        monkeypatch.setenv(var_name, value)
    return _mock_env_vars

@pytest.fixture
def mock_oauth_authorize_redirect(monkeypatch):
    def _mock_oauth_authorize_redirect(side_effect=None):
        with patch("src.routes.oauth.pingfed.authorize_redirect", side_effect=side_effect) as mock_authorize_redirect:
            yield mock_authorize_redirect
    return _mock_oauth_authorize_redirect


def test_authcallback_endpoint_success(mock_oauth_authorize_access_token):
    # Successful token exchange
    mock_oauth_authorize_access_token.return_value = {
        "access_token": "mock_access_token",
        "id_token": "mock_id_token",
        "refresh_token": "mock_refresh_token"
    }

    response = client.get("/authcallback")
    assert response.status_code == 307  # Temporary redirect status code
    assert "Location" in response.headers  # Check if Location header is present
    assert "access_token" in response.headers["Location"]  # Check if access token is in the redirect URL
    assert "id_token" in response.headers["Location"]  # Check if id token is in the redirect URL
    assert "refresh_token" in response.headers["Location"]  # Check if refresh token is in the redirect URL

def test_authcallback_endpoint_oauth_error(mock_oauth_authorize_access_token):
    # Mock OAuth error during token exchange
    mock_oauth_authorize_access_token.side_effect = Exception("Mocked OAuth Error")

    with pytest.raises(HTTPException) as exc_info:
        client.get("/authcallback")

    assert exc_info.value.status_code == 500  # Internal Server Error

def test_authcallback_endpoint_other_errors(mock_oauth_authorize_access_token):
    # Mock other errors during token exchange
    mock_oauth_authorize_access_token.side_effect = RuntimeError("Mocked Runtime Error")

    with pytest.raises(HTTPException) as exc_info:
        client.get("/authcallback")

    assert exc_info.value.status_code == 500  # Internal Server Error

def test_authcallback_endpoint_missing_tokens(mock_oauth_authorize_access_token):
    # Mock missing tokens in the response
    mock_oauth_authorize_access_token.return_value = {}

    with pytest.raises(HTTPException) as exc_info:
        client.get("/authcallback")

    assert exc_info.value.status_code == 500  # Internal Server Error

def test_authcallback_endpoint_invalid_tokens(mock_oauth_authorize_access_token):
    # Mock invalid tokens in the response (e.g., None or empty strings)
    mock_oauth_authorize_access_token.return_value = {
        "access_token": None,
        "id_token": "",
        "refresh_token": None
    }

    with pytest.raises(HTTPException) as exc_info:
        client.get("/authcallback")

    assert exc_info.value.status_code == 500  # Internal Server Error

# Helper fixtures for mocking OAuth functions

@pytest.fixture
def mock_oauth_authorize_access_token(monkeypatch):
    def _mock_oauth_authorize_access_token(side_effect=None):
        with patch("src.routes.oauth.pingfed.authorize_access_token", side_effect=side_effect) as mock_authorize_access_token:
            yield mock_authorize_access_token
    return _mock_oauth_authorize_access_token



def test_logout_endpoint_success(mock_remove_token_from_cache):
    # Successful logout with valid headers
    headers = {
        "Authorization": "Bearer mock_access_token",
        "ID-Token": "Bearer mock_id_token"
    }

    mock_remove_token_from_cache.return_value = None

    response = client.get("/logout", headers=headers)
    assert response.status_code == 200  # OK status code
    assert response.json() == {"message": "You are successfully logged out"}  # Check response message
    mock_remove_token_from_cache.assert_called_once()  # Check if token removal was called

def test_logout_endpoint_invalid_authorization_scheme(mock_remove_token_from_cache):
    # Invalid authorization scheme in headers
    headers = {
        "Authorization": "Invalid mock_access_token"
    }

    response = client.get("/logout", headers=headers)
    assert response.status_code == 200  # OK status code
    assert response.json() == {"message": "Invalid Authorization Scheme"}  # Check response message
    mock_remove_token_from_cache.assert_not_called()  # Check if token removal was not called

def test_logout_endpoint_missing_authorization_header(mock_remove_token_from_cache):
    # Missing Authorization header
    headers = {}

    response = client.get("/logout", headers=headers)
    assert response.status_code == 200  # OK status code
    assert response.json() == {"message": "You are not logged in"}  # Check response message
    mock_remove_token_from_cache.assert_not_called()  # Check if token removal was not called

def test_logout_endpoint_missing_id_token_header(mock_remove_token_from_cache):
    # Missing ID-Token header but present Authorization header
    headers = {
        "Authorization": "Bearer mock_access_token"
    }

    response = client.get("/logout", headers=headers)
    assert response.status_code == 200  # OK status code
    assert response.json() == {"message": "You are successfully logged out"}  # Check response message
    mock_remove_token_from_cache.assert_called_once()  # Check if token removal was called

def test_logout_endpoint_error_removing_tokens(mock_remove_token_from_cache):
    # Error removing tokens from cache (e.g., due to some internal error)
    headers = {
        "Authorization": "Bearer mock_access_token",
        "ID-Token": "Bearer mock_id_token"
    }

    mock_remove_token_from_cache.side_effect = Exception("Mocked Error Removing Tokens")

    with pytest.raises(HTTPException) as exc_info:
        client.get("/logout", headers=headers)

    assert exc_info.value.status_code == 500  # Internal Server Error

# Helper fixtures for mocking token cache functions

@pytest.fixture
def mock_remove_token_from_cache(monkeypatch):
    def _mock_remove_token_from_cache(side_effect=None):
        with patch("src.routes.remove_token_from_cache", side_effect=side_effect) as mock_remove_token:
            yield mock_remove_token
    return _mock_remove_token_from_cache


def test_upgrade_endpoint_success(mock_db_session, mock_verify_admin_token, mock_alembic_upgrade):
    # Successful upgrade with valid admin token and database session
    mock_verify_admin_token.return_value = None
    mock_alembic_upgrade.return_value = None

    response = client.get("/upgrade", headers={"x-token": "valid_session_key"})
    assert response.status_code == 200  # OK status code

    # Check if lock_db and unlock_db were called
    lock_db.assert_called_once_with(mock_db_session)
    unlock_db.assert_called_once_with(mock_db_session)

    # Check if alembic upgrade was called
    mock_alembic_upgrade.assert_called_once()

def test_upgrade_endpoint_db_locked(mock_db_session, mock_verify_admin_token):
    # Upgrade when database is already locked
    mock_verify_admin_token.return_value = None
    with patch("src.database.dbutils.is_db_locked", return_value=True):
        with pytest.raises(HTTPException) as exc_info:
            client.get("/upgrade", headers={"x-token": "valid_session_key"})

        assert exc_info.value.status_code == 503  # Service Unavailable

def test_upgrade_endpoint_invalid_admin_token(mock_db_session, mock_verify_admin_token):
    # Upgrade with invalid admin token
    mock_verify_admin_token.side_effect = HTTPException(status_code=401, detail="Invalid Admin Token")

    with pytest.raises(HTTPException) as exc_info:
        client.get("/upgrade", headers={"x-token": "invalid_session_key"})

    assert exc_info.value.status_code == 401  # Unauthorized

def test_upgrade_endpoint_alembic_upgrade_error(mock_db_session, mock_verify_admin_token, mock_alembic_upgrade):
    # Error during alembic upgrade process
    mock_verify_admin_token.return_value = None
    mock_alembic_upgrade.side_effect = Exception("Mocked Alembic Upgrade Error")

    with pytest.raises(HTTPException) as exc_info:
        client.get("/upgrade", headers={"x-token": "valid_session_key"})

    assert exc_info.value.status_code == 500  # Internal Server Error

    # Check if lock_db and unlock_db were called
    lock_db.assert_called_once_with(mock_db_session)
    unlock_db.assert_called_once_with(mock_db_session)

def test_upgrade_endpoint_lock_db_error(mock_db_session, mock_verify_admin_token):
    # Error locking the database before upgrade
    mock_verify_admin_token.return_value = None
    with patch("src.database.dbutils.lock_db", side_effect=Exception("Mocked Lock DB Error")):
        with pytest.raises(HTTPException) as exc_info:
            client.get("/upgrade", headers={"x-token": "valid_session_key"})

        assert exc_info.value.status_code == 500  # Internal Server Error

def test_upgrade_endpoint_unlock_db_error(mock_db_session, mock_verify_admin_token, mock_alembic_upgrade):
    # Error unlocking the database after upgrade
    mock_verify_admin_token.return_value = None
    mock_alembic_upgrade.return_value = None

    with patch("src.database.dbutils.unlock_db", side_effect=Exception("Mocked Unlock DB Error")):
        with pytest.raises(HTTPException) as exc_info:
            client.get("/upgrade", headers={"x-token": "valid_session_key"})

        assert exc_info.value.status_code == 500  # Internal Server Error

        # Check if lock_db was called but not unlock_db due to exception
        lock_db.assert_called_once_with(mock_db_session)
        unlock_db.assert_not_called()

# Helper fixtures for mocking dependencies

@pytest.fixture
def mock_db_session():
    db_session = MagicMock()
    db_session.scalar.return_value = db_session
    db_session.is_db_locked = False
    return db_session

@pytest.fixture
def mock_verify_admin_token(monkeypatch):
    def _mock_verify_admin_token(return_value=None, side_effect=None):
        with patch("src.dependables.verify_admin_token", return_value=return_value, side_effect=side_effect) as mock_verify_admin_token:
            yield mock_verify_admin_token
    return _mock_verify_admin_token

@pytest.fixture
def mock_alembic_upgrade(monkeypatch):
    def _mock_alembic_upgrade(return_value=None, side_effect=None):
        with patch("alembic.command.upgrade", return_value=return_value, side_effect=side_effect) as mock_alembic_upgrade:
            yield mock_alembic_upgrade
    return _mock_alembic_upgrade

@pytest.fixture
def mock_lock_db(monkeypatch):
    def _mock_lock_db(side_effect=None):
        with patch("src.database.dbutils.lock_db", side_effect=side_effect) as mock_lock_db:
            yield mock_lock_db
    return _mock_lock_db

@pytest.fixture
def mock_unlock_db(monkeypatch):
    def _mock_unlock_db(side_effect=None):
        with patch("src.database.dbutils.unlock_db", side_effect=side_effect) as mock_unlock_db:
            yield mock_unlock_db
    return _mock_unlock_db


def test_vars_endpoint_success(mock_db_session, mock_verify_admin_token, mock_execute_queries):
    # Successful execution with valid admin token and database session
    mock_verify_admin_token.return_value = None
    mock_execute_queries.return_value = [
        {"tables_in_schema": "table1, table2"},
        {"users_columns": "column1, column2"},
        {"users_count": 10},
        {"max_user_id": 100},
        {"metrics_count": 50},
        {"max_eb_sales_unit": 200},
        {"users2_count": 20},
        {"max_user_id_users2": 150},
        {"admins": "admin1, admin2"},
        {"powerUsers": "powerUser1, powerUser2"}
    ]

    response = client.get("/vars", headers={"x-token": "valid_session_key"})
    assert response.status_code == 200  # OK status code

    # Check if queries were executed
    mock_execute_queries.assert_called_once()

def test_vars_endpoint_invalid_admin_token(mock_db_session, mock_verify_admin_token):
    # Invalid admin token
    mock_verify_admin_token.side_effect = HTTPException(status_code=401, detail="Invalid Admin Token")

    with pytest.raises(HTTPException) as exc_info:
        client.get("/vars", headers={"x-token": "invalid_session_key"})

    assert exc_info.value.status_code == 401  # Unauthorized

def test_vars_endpoint_db_connection_error(mock_db_session, mock_verify_admin_token):
    # Error connecting to the database
    mock_verify_admin_token.return_value = None
    with patch("src.routes.create_engine", side_effect=Exception("Mocked DB Connection Error")):
        with pytest.raises(HTTPException) as exc_info:
            client.get("/vars", headers={"x-token": "valid_session_key"})

        assert exc_info.value.status_code == 500  # Internal Server Error

def test_vars_endpoint_query_execution_error(mock_db_session, mock_verify_admin_token, mock_execute_queries):
    # Error executing queries on the database
    mock_verify_admin_token.return_value = None
    mock_execute_queries.side_effect = Exception("Mocked Query Execution Error")

    with pytest.raises(HTTPException) as exc_info:
        client.get("/vars", headers={"x-token": "valid_session_key"})

    assert exc_info.value.status_code == 500  # Internal Server Error

    # Check if queries were attempted to be executed
    mock_execute_queries.assert_called_once()

def test_vars_endpoint_environment_variable_error(mock_db_session, mock_verify_admin_token):
    # Error due to missing or invalid environment variables
    mock_verify_admin_token.return_value = None
    with patch("os.getenv", side_effect=Exception("Mocked Environment Variable Error")):
        with pytest.raises(HTTPException) as exc_info:
            client.get("/vars", headers={"x-token": "valid_session_key"})

        assert exc_info.value.status_code == 500  # Internal Server Error

# Helper fixtures for mocking dependencies

@pytest.fixture
def mock_db_session():
    db_session = MagicMock()
    db_session.scalar.return_value = db_session
    db_session.is_db_locked = False
    return db_session

@pytest.fixture
def mock_verify_admin_token(monkeypatch):
    def _mock_verify_admin_token(return_value=None, side_effect=None):
        with patch("src.dependables.verify_admin_token", return_value=return_value, side_effect=side_effect) as mock_verify_admin_token:
            yield mock_verify_admin_token
    return _mock_verify_admin_token

@pytest.fixture
def mock_execute_queries(monkeypatch):
    def _mock_execute_queries(return_value=None, side_effect=None):
        with patch("src.routes.engine.connect") as mock_engine_connect:
            mock_con = mock_engine_connect.return_value.__enter__.return_value

            def execute(text):
                if side_effect is not None:
                    raise side_effect
                return return_value

            mock_con.execute.side_effect = execute

            yield mock_con.execute

    return _mock_execute_queries


def test_clear_cache_endpoint_success(mock_db_session, mock_verify_admin_token, mock_clear_token_cache):
    # Successful cache clearance with valid admin token and database session
    mock_verify_admin_token.return_value = None
    mock_clear_token_cache.return_value = None

    response = client.get("/clear_cache", headers={"x-token": "valid_session_key"})
    assert response.status_code == 200  # OK status code

    # Check if clear_token_cache was called
    mock_clear_token_cache.assert_called_once()

def test_clear_cache_endpoint_invalid_admin_token(mock_db_session, mock_verify_admin_token):
    # Invalid admin token
    mock_verify_admin_token.side_effect = HTTPException(status_code=401, detail="Invalid Admin Token")

    with pytest.raises(HTTPException) as exc_info:
        client.get("/clear_cache", headers={"x-token": "invalid_session_key"})

    assert exc_info.value.status_code == 401  # Unauthorized

def test_clear_cache_endpoint_error_clearing_cache(mock_db_session, mock_verify_admin_token, mock_clear_token_cache):
    # Error clearing the cache
    mock_verify_admin_token.return_value = None
    mock_clear_token_cache.side_effect = Exception("Mocked Cache Clearing Error")

    with pytest.raises(HTTPException) as exc_info:
        client.get("/clear_cache", headers={"x-token": "valid_session_key"})

    assert exc_info.value.status_code == 500  # Internal Server Error

    # Check if clear_token_cache was called
    mock_clear_token_cache.assert_called_once()

def test_clear_cache_endpoint_logging_error(mock_db_session, mock_verify_admin_token, mock_clear_token_cache, caplog):
    # Logging error after successful cache clearance (e.g., logging.info)
    mock_verify_admin_token.return_value = None
    mock_clear_token_cache.return_value = None

    with caplog.at_level("INFO"):
        response = client.get("/clear_cache", headers={"x-token": "valid_session_key"})
        assert response.status_code == 200  # OK status code

        # Check if log message was generated
        assert "Cache Cleared" in caplog.text

# Helper fixtures for mocking dependencies

@pytest.fixture
def mock_db_session():
    db_session = MagicMock()
    db_session.scalar.return_value = db_session
    db_session.is_db_locked = False
    return db_session

@pytest.fixture
def mock_verify_admin_token(monkeypatch):
    def _mock_verify_admin_token(return_value=None, side_effect=None):
        with patch("src.dependables.verify_admin_token", return_value=return_value, side_effect=side_effect) as mock_verify_admin_token:
            yield mock_verify_admin_token
    return _mock_verify_admin_token

@pytest.fixture
def mock_clear_token_cache(monkeypatch):
    def _mock_clear_token_cache(return_value=None, side_effect=None):
        with patch("src.routes.clear_token_cache", return_value=return_value, side_effect=side_effect) as mock_clear_token_cache:
            yield mock_clear_token_cache
    return _mock_clear_token_cache