Untitled

from mock import AsyncMock
import pytest

from sqlalchemy import func
from fastapi import Depends, HTTPException, Request
from unittest.mock import patch, MagicMock
from src.dependables import auth,verify_admin_token,maintenance
from src.database import SessionLocal, dbutils
from src.database.models.Metric import MetricModel
from src.database.models.User import *
from pytest import MonkeyPatch
from src.database.models.Analytics import AnalyticsModel
from src.dependables import auth, db
from sqlalchemy.orm import Session, sessionmaker
import src.dependables.__init__


# Test case for verify_admin_token with valid API key

@pytest.mark.asyncio
async def test_verify_admin_token(mock_db_session, monkeypatch):

    request = MagicMock()
    request.state.db = mock_db_session

    monkeypatch.setenv('MIDDLEWARE_SESSION_KEY', 'valid_session_key')



    api_key_header = MagicMock(return_value='invalid_token')

    result = await verify_admin_token(api_key)
    assert result is None

@pytest.mark.asyncio
async def test_verify_admin_token_invalid(mock_db_session):
    request = MagicMock()
    request.state.db = mock_db_session


    with pytest.raises(HTTPException) as exc_info:
        await verify_admin_token(api_key)

    assert exc_info.value.status_code == 401
    assert exc_info.value.detail == "Invalid Admin Token"


# def test_db_session(mock_db_session,mock_request):
#     mock_request = MagicMock()
#     mock_db_session = TestingSessionLocal()

#     with patch('src.database.__init__.SessionLocal', return_value = mock_db_session):    
#         generator = db(mock_request)
   
#         db_session = next(generator)
#         assert db_session == mock_db_session
#         assert mock_request.state.db == mock_db_session
   
#         generator.close()
#         mock_db_session.close.assert_called_once()


def test_auth_with_user_query(mock_generic_model, mock_db_session):
    
    UserModel.query = MagicMock(return_value=mock_generic_model)
    mock_user = MagicMock()
    mock_generic_model.first.return_value = mock_user
    mock_user.role = 'admin'
    request = MagicMock()
    request.state.db = mock_db_session
    request.headers.get.return_value = None

    token_headers = '{"user" : "test_user"}'

    result = auth(request, token_headers)
  
    assert request.state.is_admin is True
    assert request.state.is_true_admin is True
    assert request.state.auth_original == mock_user
    assert request.state.auth == mock_user
    assert result == mock_user
    assert result.role == 'admin'

def test_user_role_is_not_admin(mock_generic_model, mock_db_session):  
    UserModel.query = MagicMock(return_value=mock_generic_model)
    mock_user = MagicMock()
    mock_generic_model.first.return_value = mock_user
    mock_user.role = None
    request = MagicMock()
    request.state.db = mock_db_session
    request.headers.get.return_value = None

    token_headers = '{"user" : "test_user"}'

    result = auth(request, token_headers) 
    assert request.state.is_true_admin is False
    assert request.state.auth_original == mock_user
    assert request.state.auth == mock_user
    assert result == mock_user
    assert result.role == None


def test_auth_token_headers_is_none(mock_generic_model, mock_db_session):  
    UserModel.query = MagicMock(return_value=mock_generic_model)
    mock_user = MagicMock()
    mock_generic_model.first.return_value = mock_user
    mock_user.role = 'admin'
    request = MagicMock()
    request.state.db = mock_db_session

    token_headers = '{"user" : "test_user"}'
    request.headers.get.return_value = '{"user" : "test_user2"}'

    result = auth(request, token_headers)
    assert result == mock_user

   
def test_auth_token_headers_none(mock_generic_model):   
    UserModel.query = MagicMock(return_value=mock_generic_model)
    request = MagicMock()
    request.headers.get.return_value = None

    with pytest.raises(HTTPException) as exc_info:
        auth(request,token_headers = None)

    assert exc_info.value.status_code == 401
    assert exc_info.value.detail ==  "You are not authenticated."


def test_auth_user_not_found(mock_generic_model, mock_db_session):
    UserModel.query = MagicMock(return_value=mock_generic_model)
    mock_user = MagicMock()
    mock_generic_model.first.return_value = None
    mock_user.role = 'admin'
    request = MagicMock()
    request.state.db = mock_db_session
    request.headers.get.return_value = None

    token_headers = '{"user" : "test_user"}'
    
    with pytest.raises(HTTPException) as exc_info:
        auth(request,token_headers, mock_db_session)

    assert exc_info.value.status_code == 403
    assert exc_info.value.detail ==  "You are not authorized to use Performance Ecosystem."


@pytest.mark.asyncio
async def test_maintenance_db_locked(mock_db_session):
    with patch("src.database.dbutils.is_db_locked", return_value=True):
        with pytest.raises(HTTPException) as excinfo:
            await src.dependables.maintenance(db=mock_db_session)

    assert excinfo.value.status_code == 503


def test_maintenance_db_unlocked(mock_db_session):
    with patch("src.database.dbutils.is_db_locked", return_value=False):
        result = src.dependables.maintenance(db=mock_db_session)
        assert result is None