hms/crates/erp-server/tests/integration/test_fixture.rs

use chrono::{NaiveDate, NaiveTime};
use erp_core::crypto::PiiCrypto;
use erp_core::events::EventBus;
use erp_dialysis::state::DialysisState;
use erp_health::dto::appointment_dto::{CreateAppointmentReq, CreateScheduleReq};
use erp_health::dto::doctor_dto::CreateDoctorReq;
use erp_health::dto::patient_dto::CreatePatientReq;
use erp_health::service::{appointment_service, doctor_service, patient_service};
use erp_health::state::HealthState;

use super::test_db::TestDb;

/// 集成测试环境 — 封装 TestDb + HealthState + 租户/操作者上下文
pub struct TestApp {
    test_db: TestDb,
    health_state: HealthState,
    dialysis_state: DialysisState,
    tenant_id: uuid::Uuid,
    operator_id: uuid::Uuid,
}

impl TestApp {
    pub async fn new() -> Self {
        let test_db = TestDb::new().await;
        let health_state = HealthState {
            db: test_db.db().clone(),
            event_bus: EventBus::new(100),
            crypto: PiiCrypto::dev_default(),
            jwt_secret: "test-jwt-secret-for-integration-tests".to_string(),
        };
        let dialysis_state = DialysisState {
            db: test_db.db().clone(),
            event_bus: health_state.event_bus.clone(),
            crypto: health_state.crypto.clone(),
        };
        Self {
            test_db,
            health_state,
            dialysis_state,
            tenant_id: uuid::Uuid::new_v4(),
            operator_id: uuid::Uuid::new_v4(),
        }
    }

    pub fn db(&self) -> &sea_orm::DatabaseConnection {
        self.test_db.db()
    }

    pub fn health_state(&self) -> &HealthState {
        &self.health_state
    }

    pub fn dialysis_state(&self) -> &DialysisState {
        &self.dialysis_state
    }

    pub fn tenant_id(&self) -> uuid::Uuid {
        self.tenant_id
    }

    pub fn operator_id(&self) -> uuid::Uuid {
        self.operator_id
    }

    // ---- Fixture 工厂方法 ----

    pub async fn create_patient(&self, name: &str) -> uuid::Uuid {
        let req = CreatePatientReq {
            name: name.to_string(),
            gender: Some("male".to_string()),
            birth_date: None,
            blood_type: None,
            id_number: None,
            allergy_history: None,
            medical_history_summary: None,
            emergency_contact_name: None,
            emergency_contact_phone: None,
            source: None,
            notes: None,
        };
        let patient = patient_service::create_patient(
            self.health_state(),
            self.tenant_id,
            Some(self.operator_id),
            req,
        )
        .await
        .expect("创建患者应成功");
        patient.id
    }

    pub async fn create_doctor(&self, name: &str) -> uuid::Uuid {
        let req = CreateDoctorReq {
            user_id: None,
            name: name.to_string(),
            department: Some("内科".to_string()),
            title: Some("主治医师".to_string()),
            specialty: Some("心血管内科".to_string()),
            license_number: None,
            bio: None,
        };
        let doctor = doctor_service::create_doctor(
            self.health_state(),
            self.tenant_id,
            Some(self.operator_id),
            req,
        )
        .await
        .expect("创建医护档案应成功");
        doctor.id
    }

    pub async fn create_schedule(&self, doctor_id: uuid::Uuid, date: NaiveDate) -> uuid::Uuid {
        let req = CreateScheduleReq {
            doctor_id,
            schedule_date: date,
            period_type: Some("am".to_string()),
            start_time: NaiveTime::from_hms_opt(9, 0, 0).unwrap(),
            end_time: NaiveTime::from_hms_opt(12, 0, 0).unwrap(),
            max_appointments: 10,
        };
        let schedule = appointment_service::create_schedule(
            self.health_state(),
            self.tenant_id,
            Some(self.operator_id),
            req,
        )
        .await
        .expect("创建排班应成功");
        schedule.id
    }

    pub async fn create_appointment(
        &self,
        patient_id: uuid::Uuid,
        doctor_id: uuid::Uuid,
        date: NaiveDate,
    ) -> uuid::Uuid {
        let req = CreateAppointmentReq {
            patient_id,
            doctor_id: Some(doctor_id),
            appointment_type: Some("outpatient".to_string()),
            appointment_date: date,
            start_time: NaiveTime::from_hms_opt(9, 0, 0).unwrap(),
            end_time: NaiveTime::from_hms_opt(9, 30, 0).unwrap(),
            notes: Some("测试预约".to_string()),
        };
        let appt = appointment_service::create_appointment(
            self.health_state(),
            self.tenant_id,
            Some(self.operator_id),
            req,
        )
        .await
        .expect("创建预约应成功");
        appt.id
    }
}