Files
celtic-life-science/tests/conftest.py
Shubhankar45 0d30c58bf0 Server backup 2026-11-07 of uncommitted work in projects/pharma-web-celtic
Snapshot of the working tree on srv1071960 (branch main), taken during
server cleanup. .env files, node_modules, builds, logs and media were excluded.
2026-11-07 05:43:12 +00:00

217 lines
6.8 KiB
Python

"""Test fixtures.
Tests run against a REAL PostgreSQL database, never SQLite. This system depends on
constraints that SQLite does not implement the same way — partial unique indexes,
composite uniques, jsonb — so testing on SQLite would mean testing a different system
from the one that ships.
Set TEST_DATABASE_URL to point at a scratch database. Docker Compose provides one:
postgresql+asyncpg://pharma:pharma@localhost:5432/pharma_test
"""
import os
import uuid
from collections.abc import AsyncGenerator
from datetime import date
import pytest
from httpx import ASGITransport, AsyncClient
from sqlalchemy import text
from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker, create_async_engine
os.environ.setdefault("SECRET_KEY", "test-secret-not-for-production")
os.environ.setdefault("ENVIRONMENT", "test")
TEST_DATABASE_URL = os.environ.get(
"TEST_DATABASE_URL", "postgresql+asyncpg://pharma:pharma@127.0.0.1:5432/pharma_test"
)
from app.auth.security import hash_password # noqa: E402
from app.common.enums import Role # noqa: E402
from app.database.all_models import Base # noqa: E402
from app.database.session import get_db # noqa: E402
from app.main import app as fastapi_app # noqa: E402
from app.organization.models import AMHeadquarters, Company, Headquarters # noqa: E402
from app.users.models import User # noqa: E402
TABLES = [
"audit_log",
"product",
"missed_visit",
"doctor_call",
"chemist_call",
"daily_call_report",
"doctor_assignment",
"chemist_assignment",
"doctor",
"chemist",
"am_headquarters",
"form_approval",
"refresh_token",
'"user"',
"headquarters",
"company",
]
@pytest.fixture(scope="session")
def anyio_backend() -> str:
return "asyncio"
@pytest.fixture(scope="session")
async def engine():
eng = create_async_engine(TEST_DATABASE_URL, poolclass=None)
async with eng.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
yield eng
await eng.dispose()
@pytest.fixture
async def session_factory(engine):
factory = async_sessionmaker(bind=engine, class_=AsyncSession, expire_on_commit=False)
async with engine.begin() as conn:
await conn.execute(text(f"TRUNCATE {', '.join(TABLES)} RESTART IDENTITY CASCADE"))
return factory
@pytest.fixture
async def db(session_factory) -> AsyncGenerator[AsyncSession, None]:
async with session_factory() as s:
yield s
@pytest.fixture
async def client(session_factory, tmp_path) -> AsyncGenerator[AsyncClient, None]:
from app.config.settings import settings
settings.PDF_STORAGE_PATH = str(tmp_path / "pdf")
async def _override_get_db() -> AsyncGenerator[AsyncSession, None]:
async with session_factory() as s:
try:
yield s
except Exception:
await s.rollback()
raise
fastapi_app.dependency_overrides[get_db] = _override_get_db
transport = ASGITransport(app=fastapi_app)
async with AsyncClient(transport=transport, base_url="http://test") as ac:
yield ac
fastapi_app.dependency_overrides.clear()
# ---------------------------------------------------------------------------
# Organisation fixture: the minimum MVP system — 1 company, 2 HQs, AGM, 2 AMs, 2 MRs.
# The second HQ/ABM/MR exist purely so the negative-scope tests (X1, X2) have someone
# to be denied.
# ---------------------------------------------------------------------------
DEFAULT_PASSWORD = "Str0ngPassw0rd!"
@pytest.fixture
async def org(db: AsyncSession) -> dict:
company = Company(id=uuid.uuid4(), name="Acme Pharma Pvt Ltd")
db.add(company)
await db.flush()
hq1 = Headquarters(
id=uuid.uuid4(), company_id=company.id, code="BBSR", name="Bhubaneswar",
district="Khordha", state="Odisha",
)
hq2 = Headquarters(
id=uuid.uuid4(), company_id=company.id, code="SBP", name="Sambalpur",
district="Sambalpur", state="Odisha",
)
db.add_all([hq1, hq2])
await db.flush()
def make(role: Role, name: str, code: str, hq_id=None) -> User:
return User(
id=uuid.uuid4(),
company_id=company.id,
email=f"{code.lower()}@acmepharma.in",
password_hash=hash_password(DEFAULT_PASSWORD),
full_name=name,
employee_code=code,
role=role,
headquarters_id=hq_id,
)
admin = make(Role.ADMIN, "System Admin", "ADM001")
gm = make(Role.AGM, "Anita Mohanty", "GM001")
am1 = make(Role.ABM, "Suresh Behera", "AM001")
am2 = make(Role.ABM, "Rakesh Sahu", "AM002")
mr1 = make(Role.MR, "Ravi Das", "MR001", hq1.id)
mr2 = make(Role.MR, "Priya Nayak", "MR002", hq2.id)
db.add_all([admin, gm, am1, am2, mr1, mr2])
await db.flush()
db.add_all(
[
AMHeadquarters(
area_manager_user_id=am1.id, headquarters_id=hq1.id,
effective_from=date.today(),
),
AMHeadquarters(
area_manager_user_id=am2.id, headquarters_id=hq2.id,
effective_from=date.today(),
),
]
)
await db.commit()
return {
"company": company, "hq1": hq1, "hq2": hq2,
"admin": admin, "gm": gm, "am1": am1, "am2": am2, "mr1": mr1, "mr2": mr2,
}
@pytest.fixture
async def approved_plan(db: AsyncSession, org: dict):
"""An empty day plan, already approved, so an end-of-day report may be filed.
For tests about end-of-day rules where the plan is incidental; the plan flow itself
is exercised through the API in tests/e2e/test_day_plan.py.
"""
from app.common.enums import DCRStatus, ReportType
from app.common.utils import utcnow
from app.reports.models import DailyCallReport
async def make(day: date | None = None, mr: str = "mr1") -> DailyCallReport:
plan = DailyCallReport(
id=uuid.uuid4(),
mr_user_id=org[mr].id,
headquarters_id=org[mr].headquarters_id,
report_date=day or date.today(),
report_type=ReportType.PLAN,
status=DCRStatus.APPROVED,
approved_at=utcnow(),
)
db.add(plan)
await db.commit()
return plan
return make
async def login(client: AsyncClient, user: User) -> dict[str, str]:
resp = await client.post(
"/api/v1/auth/login",
json={"email": user.email, "password": DEFAULT_PASSWORD},
)
assert resp.status_code == 200, resp.text
return {"Authorization": f"Bearer {resp.json()['access_token']}"}
@pytest.fixture
async def auth(client: AsyncClient, org: dict) -> dict[str, dict[str, str]]:
"""Ready-made Authorization headers for every role."""
return {
key: await login(client, org[key])
for key in ("admin", "gm", "am1", "am2", "mr1", "mr2")
}