Aegis/backend/tests/conftest.py

"""Pytest fixtures and configuration for backend tests."""

import pytest
from fastapi.testclient import TestClient
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from sqlalchemy.pool import StaticPool

from app.main import app
from app.database import Base, get_db
from app.auth import hash_password
from app.models.user import User

# Use in-memory SQLite for tests
SQLALCHEMY_DATABASE_URL = "sqlite:///:memory:"

engine = create_engine(
    SQLALCHEMY_DATABASE_URL,
    connect_args={"check_same_thread": False},
    poolclass=StaticPool,
)
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)


def override_get_db():
    """Override the database dependency for testing."""
    db = TestingSessionLocal()
    try:
        yield db
    finally:
        db.close()


@pytest.fixture(scope="function")
def db():
    """Create a fresh database for each test."""
    Base.metadata.create_all(bind=engine)
    db = TestingSessionLocal()
    yield db
    db.close()
    Base.metadata.drop_all(bind=engine)


@pytest.fixture(scope="function")
def client(db):
    """Create a test client with database override."""
    app.dependency_overrides[get_db] = override_get_db
    Base.metadata.create_all(bind=engine)
    
    with TestClient(app) as test_client:
        yield test_client
    
    Base.metadata.drop_all(bind=engine)
    app.dependency_overrides.clear()


@pytest.fixture(scope="function")
def admin_user(db):
    """Create an admin user for testing."""
    user = User(
        username="admin",
        email="admin@test.com",
        hashed_password=hash_password("admin123"),
        role="admin",
        is_active=True,
    )
    db.add(user)
    db.commit()
    db.refresh(user)
    return user


@pytest.fixture(scope="function")
def red_tech_user(db):
    """Create a red_tech user for testing."""
    user = User(
        username="redtech",
        email="redtech@test.com",
        hashed_password=hash_password("redtech123"),
        role="red_tech",
        is_active=True,
    )
    db.add(user)
    db.commit()
    db.refresh(user)
    return user


@pytest.fixture(scope="function")
def blue_tech_user(db):
    """Create a blue_tech user for testing."""
    user = User(
        username="bluetech",
        email="bluetech@test.com",
        hashed_password=hash_password("bluetech123"),
        role="blue_tech",
        is_active=True,
    )
    db.add(user)
    db.commit()
    db.refresh(user)
    return user


@pytest.fixture(scope="function")
def red_lead_user(db):
    """Create a red_lead user for testing."""
    user = User(
        username="redlead",
        email="redlead@test.com",
        hashed_password=hash_password("redlead123"),
        role="red_lead",
        is_active=True,
    )
    db.add(user)
    db.commit()
    db.refresh(user)
    return user


@pytest.fixture(scope="function")
def blue_lead_user(db):
    """Create a blue_lead user for testing."""
    user = User(
        username="bluelead",
        email="bluelead@test.com",
        hashed_password=hash_password("bluelead123"),
        role="blue_lead",
        is_active=True,
    )
    db.add(user)
    db.commit()
    db.refresh(user)
    return user


@pytest.fixture(scope="function")
def admin_token(client, admin_user):
    """Get an auth token for the admin user."""
    response = client.post(
        "/api/v1/auth/login",
        data={"username": "admin", "password": "admin123"},
    )
    return response.json()["access_token"]


@pytest.fixture(scope="function")
def red_tech_token(client, red_tech_user):
    """Get an auth token for the red_tech user."""
    response = client.post(
        "/api/v1/auth/login",
        data={"username": "redtech", "password": "redtech123"},
    )
    return response.json()["access_token"]


@pytest.fixture(scope="function")
def auth_headers(admin_token):
    """Return authorization headers for admin user."""
    return {"Authorization": f"Bearer {admin_token}"}


@pytest.fixture(scope="function")
def red_tech_headers(red_tech_token):
    """Return authorization headers for red_tech user."""
    return {"Authorization": f"Bearer {red_tech_token}"}


@pytest.fixture(scope="function")
def blue_tech_token(client, blue_tech_user):
    """Get an auth token for the blue_tech user."""
    response = client.post(
        "/api/v1/auth/login",
        data={"username": "bluetech", "password": "bluetech123"},
    )
    return response.json()["access_token"]


@pytest.fixture(scope="function")
def blue_tech_headers(blue_tech_token):
    """Return authorization headers for blue_tech user."""
    return {"Authorization": f"Bearer {blue_tech_token}"}


@pytest.fixture(scope="function")
def red_lead_token(client, red_lead_user):
    """Get an auth token for the red_lead user."""
    response = client.post(
        "/api/v1/auth/login",
        data={"username": "redlead", "password": "redlead123"},
    )
    return response.json()["access_token"]


@pytest.fixture(scope="function")
def red_lead_headers(red_lead_token):
    """Return authorization headers for red_lead user."""
    return {"Authorization": f"Bearer {red_lead_token}"}


@pytest.fixture(scope="function")
def blue_lead_token(client, blue_lead_user):
    """Get an auth token for the blue_lead user."""
    response = client.post(
        "/api/v1/auth/login",
        data={"username": "bluelead", "password": "bluelead123"},
    )
    return response.json()["access_token"]


@pytest.fixture(scope="function")
def blue_lead_headers(blue_lead_token):
    """Return authorization headers for blue_lead user."""
    return {"Authorization": f"Bearer {blue_lead_token}"}