diff --git a/server/tests/close_case_test.rs b/server/tests/close_case_test.rs new file mode 100644 index 0000000..4af4b08 --- /dev/null +++ b/server/tests/close_case_test.rs @@ -0,0 +1,433 @@ +use std::collections::HashMap; +use std::path::{Path, PathBuf}; +use std::sync::Arc; +use std::time::Duration; + +use axum::body::Body; +use axum::http::{header, Request, StatusCode}; +use doctate_server::analyze; +use doctate_server::config::{Config, User}; +use serde_json::{json, Value}; +use tower::util::ServiceExt; +use wiremock::matchers::{method, path}; +use wiremock::{Mock, MockServer, ResponseTemplate}; + +// --------------------------------------------------------------------- +// Fixture helpers +// --------------------------------------------------------------------- + +fn unique_tmp(label: &str) -> PathBuf { + std::env::temp_dir().join(format!( + "doctate-close-{label}-{}-{}", + std::process::id(), + uuid::Uuid::new_v4() + )) +} + +fn make_user(slug: &str) -> User { + User { + slug: slug.into(), + api_key: format!("key-{slug}"), + web_password: bcrypt::hash("s", 4).unwrap(), + role: "doctor".into(), + whisper: Default::default(), + } +} + +fn config_with_llm(data_path: PathBuf, llm_url: String) -> Arc { + let users = vec![make_user("dr_a")]; + let api_keys: HashMap = users + .iter() + .map(|u| (u.api_key.clone(), u.slug.clone())) + .collect(); + Arc::new(Config { + data_path, + users, + api_keys, + llm_url, + llm_api_key: "test-key".into(), + llm_model: "test-model".into(), + ..Config::test_default() + }) +} + +fn config_without_llm(data_path: PathBuf) -> Arc { + let users = vec![make_user("dr_a")]; + let api_keys: HashMap = users + .iter() + .map(|u| (u.api_key.clone(), u.slug.clone())) + .collect(); + Arc::new(Config { + data_path, + users, + api_keys, + ..Config::test_default() + }) +} + +fn seed_case(data_path: &Path, slug: &str, case_id: &str) -> PathBuf { + let dir = data_path.join(slug).join("open").join(case_id); + std::fs::create_dir_all(&dir).unwrap(); + dir +} + +fn seed_recording(case_dir: &Path, ts_hms: &str, transcript: Option<&str>) { + let filename = format!("2026-04-15T{ts_hms}Z.m4a"); + std::fs::write(case_dir.join(&filename), b"audio-bytes").unwrap(); + if let Some(text) = transcript { + let tx_name = format!("2026-04-15T{ts_hms}Z.transcript.txt"); + std::fs::write(case_dir.join(tx_name), text).unwrap(); + } +} + +async fn login(app: axum::Router, slug: &str) -> String { + let body = format!("slug={slug}&password=s"); + let resp = app + .oneshot( + Request::builder() + .method("POST") + .uri("/web/login") + .header(header::CONTENT_TYPE, "application/x-www-form-urlencoded") + .body(Body::from(body)) + .unwrap(), + ) + .await + .unwrap(); + for v in resp.headers().get_all(header::SET_COOKIE).iter() { + let s = v.to_str().unwrap(); + if let Some(pair) = s.split(';').next() + && pair.starts_with("session=") + { + return pair.to_string(); + } + } + panic!("no session cookie after login"); +} + +fn close_request(case_id: &str, cookie: &str) -> Request { + Request::builder() + .method("POST") + .uri(format!("/web/cases/{case_id}/close")) + .header(header::COOKIE, cookie) + .body(Body::empty()) + .unwrap() +} + +// --------------------------------------------------------------------- +// HTTP-level precondition tests +// --------------------------------------------------------------------- + +#[tokio::test] +async fn close_without_cookie_redirects_to_login() { + let config = config_with_llm(unique_tmp("a"), "http://unused".into()); + let app = doctate_server::create_router(config); + let case_id = "11111111-1111-1111-1111-111111111111"; + let resp = app + .oneshot( + Request::builder() + .method("POST") + .uri(format!("/web/cases/{case_id}/close")) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(resp.status(), StatusCode::FOUND); +} + +#[tokio::test] +async fn close_foreign_case_returns_404() { + let config = config_with_llm(unique_tmp("b"), "http://unused".into()); + // Seed a case owned by someone else. + let foreign_case = "22222222-2222-2222-2222-222222222222"; + let foreign_dir = config.data_path.join("dr_other/open").join(foreign_case); + std::fs::create_dir_all(&foreign_dir).unwrap(); + seed_recording(&foreign_dir, "10-00-00", Some("text")); + + let app = doctate_server::create_router(config); + let cookie = login(app.clone(), "dr_a").await; + + let resp = app.oneshot(close_request(foreign_case, &cookie)).await.unwrap(); + assert_eq!(resp.status(), StatusCode::NOT_FOUND); +} + +#[tokio::test] +async fn close_invalid_uuid_returns_400() { + let config = config_with_llm(unique_tmp("c"), "http://unused".into()); + let app = doctate_server::create_router(config); + let cookie = login(app.clone(), "dr_a").await; + + let resp = app.oneshot(close_request("not-a-uuid", &cookie)).await.unwrap(); + assert_eq!(resp.status(), StatusCode::BAD_REQUEST); +} + +#[tokio::test] +async fn close_case_without_recordings_returns_400() { + let config = config_with_llm(unique_tmp("d"), "http://unused".into()); + let case_id = "11111111-1111-1111-1111-111111111111"; + seed_case(&config.data_path, "dr_a", case_id); + // No .m4a files. + + let app = doctate_server::create_router(config); + let cookie = login(app.clone(), "dr_a").await; + + let resp = app.oneshot(close_request(case_id, &cookie)).await.unwrap(); + assert_eq!(resp.status(), StatusCode::BAD_REQUEST); +} + +#[tokio::test] +async fn close_case_with_missing_transcript_returns_400() { + let config = config_with_llm(unique_tmp("e"), "http://unused".into()); + let case_id = "11111111-1111-1111-1111-111111111111"; + let case_dir = seed_case(&config.data_path, "dr_a", case_id); + seed_recording(&case_dir, "10-00-00", Some("ok")); + seed_recording(&case_dir, "10-05-00", None); // still transcribing + + let app = doctate_server::create_router(config); + let cookie = login(app.clone(), "dr_a").await; + + let resp = app.oneshot(close_request(case_id, &cookie)).await.unwrap(); + assert_eq!(resp.status(), StatusCode::BAD_REQUEST); +} + +#[tokio::test] +async fn close_case_without_llm_returns_503() { + let config = config_without_llm(unique_tmp("f")); + let case_id = "11111111-1111-1111-1111-111111111111"; + let case_dir = seed_case(&config.data_path, "dr_a", case_id); + seed_recording(&case_dir, "10-00-00", Some("ok")); + + let app = doctate_server::create_router(config); + let cookie = login(app.clone(), "dr_a").await; + + let resp = app.oneshot(close_request(case_id, &cookie)).await.unwrap(); + assert_eq!(resp.status(), StatusCode::SERVICE_UNAVAILABLE); +} + +// --------------------------------------------------------------------- +// HTTP-level happy path + race +// --------------------------------------------------------------------- + +#[tokio::test] +async fn close_case_happy_path_writes_input_and_redirects() { + let config = config_with_llm(unique_tmp("g"), "http://unused".into()); + let case_id = "11111111-1111-1111-1111-111111111111"; + let case_dir = seed_case(&config.data_path, "dr_a", case_id); + seed_recording(&case_dir, "10-00-00", Some("Patient klagt über Knie.")); + seed_recording(&case_dir, "10-05-00", Some("Korrektur: links, nicht rechts.")); + + let app = doctate_server::create_router(config); + let cookie = login(app.clone(), "dr_a").await; + + let resp = app.oneshot(close_request(case_id, &cookie)).await.unwrap(); + assert_eq!(resp.status(), StatusCode::SEE_OTHER); + assert_eq!( + resp.headers().get(header::LOCATION).unwrap().to_str().unwrap(), + format!("/web/cases/{case_id}") + ); + + let input_path = case_dir.join("analysis_input_v1.json"); + assert!(input_path.exists(), "analysis_input_v1.json missing"); + + let raw = std::fs::read_to_string(&input_path).unwrap(); + let parsed: Value = serde_json::from_str(&raw).unwrap(); + assert_eq!(parsed["version"], 1); + let recs = parsed["recordings"].as_array().unwrap(); + assert_eq!(recs.len(), 2); + assert_eq!(recs[0]["recorded_at"], "2026-04-15T10:00:00Z"); + assert_eq!(recs[0]["text"], "Patient klagt über Knie."); + assert_eq!(recs[1]["recorded_at"], "2026-04-15T10:05:00Z"); + assert!(parsed["last_recording_mtime"].is_string()); +} + +#[tokio::test] +async fn close_case_second_time_returns_409() { + let config = config_with_llm(unique_tmp("h"), "http://unused".into()); + let case_id = "11111111-1111-1111-1111-111111111111"; + let case_dir = seed_case(&config.data_path, "dr_a", case_id); + seed_recording(&case_dir, "10-00-00", Some("text")); + + let app = doctate_server::create_router(config); + let cookie = login(app.clone(), "dr_a").await; + + let first = app.clone().oneshot(close_request(case_id, &cookie)).await.unwrap(); + assert_eq!(first.status(), StatusCode::SEE_OTHER); + + let second = app.oneshot(close_request(case_id, &cookie)).await.unwrap(); + assert_eq!(second.status(), StatusCode::CONFLICT); +} + +#[tokio::test] +async fn close_case_skips_blank_transcript_from_recordings() { + let config = config_with_llm(unique_tmp("i"), "http://unused".into()); + let case_id = "11111111-1111-1111-1111-111111111111"; + let case_dir = seed_case(&config.data_path, "dr_a", case_id); + seed_recording(&case_dir, "10-00-00", Some("echt")); + seed_recording(&case_dir, "10-05-00", Some(" ")); // blank + seed_recording(&case_dir, "10-10-00", Some("auch echt")); + + let app = doctate_server::create_router(config); + let cookie = login(app.clone(), "dr_a").await; + + let resp = app.oneshot(close_request(case_id, &cookie)).await.unwrap(); + assert_eq!(resp.status(), StatusCode::SEE_OTHER); + + let raw = std::fs::read_to_string(case_dir.join("analysis_input_v1.json")).unwrap(); + let parsed: Value = serde_json::from_str(&raw).unwrap(); + let recs = parsed["recordings"].as_array().unwrap(); + assert_eq!(recs.len(), 2, "blank transcript must be filtered out"); +} + +// --------------------------------------------------------------------- +// Worker + wiremock integration +// --------------------------------------------------------------------- + +#[tokio::test] +async fn analyze_worker_writes_document_via_wiremock() { + let tmp = unique_tmp("w"); + let case_dir = tmp.join("dr_a/open/11111111-1111-1111-1111-111111111111"); + std::fs::create_dir_all(&case_dir).unwrap(); + + let input = json!({ + "version": 1, + "last_recording_mtime": "2026-04-15T10:00:00Z", + "recordings": [ + { "recorded_at": "2026-04-15T10:00:00Z", "text": "Patient mit Knie." } + ] + }); + std::fs::write( + case_dir.join("analysis_input_v1.json"), + serde_json::to_vec_pretty(&input).unwrap(), + ) + .unwrap(); + + let mock = MockServer::start().await; + Mock::given(method("POST")) + .and(path("/v1/chat/completions")) + .respond_with(ResponseTemplate::new(200).set_body_json(json!({ + "choices": [{ + "message": { "content": "Zusammenfassung: Knie-Beschwerden." } + }] + }))) + .mount(&mock) + .await; + + let config = config_with_llm(tmp.clone(), mock.uri()); + let (tx, rx) = analyze::channel(); + let client = reqwest::Client::new(); + let handle = tokio::spawn(analyze::worker::run(rx, config, client)); + + tx.send(analyze::AnalyzeJob { + case_dir: case_dir.clone(), + version: 1, + }) + .unwrap(); + + // Poll for the document (worker is in a separate task). + let document_path = case_dir.join("document_v1.md"); + let deadline = std::time::Instant::now() + Duration::from_secs(5); + while !document_path.exists() { + if std::time::Instant::now() > deadline { + panic!("document_v1.md not written within 5s"); + } + tokio::time::sleep(Duration::from_millis(20)).await; + } + + let content = std::fs::read_to_string(&document_path).unwrap(); + assert!( + content.contains("Knie-Beschwerden"), + "unexpected content: {content}" + ); + + drop(tx); + let _ = tokio::time::timeout(Duration::from_secs(2), handle).await; +} + +// --------------------------------------------------------------------- +// Recovery +// --------------------------------------------------------------------- + +#[tokio::test] +async fn recovery_enqueues_pending_analysis() { + let tmp = unique_tmp("r1"); + let case_dir = tmp.join("dr_a/open/11111111-1111-1111-1111-111111111111"); + std::fs::create_dir_all(&case_dir).unwrap(); + std::fs::write(case_dir.join("analysis_input_v1.json"), "{}").unwrap(); + + let (tx, mut rx) = analyze::channel(); + analyze::recovery::scan_and_enqueue(&tmp, &tx).await; + + let job = rx.try_recv().expect("expected one job"); + assert_eq!(job.version, 1); + assert_eq!(job.case_dir, case_dir); + assert!(rx.try_recv().is_err(), "no further jobs expected"); +} + +#[tokio::test] +async fn recovery_skips_completed_analysis() { + let tmp = unique_tmp("r2"); + let case_dir = tmp.join("dr_a/open/11111111-1111-1111-1111-111111111111"); + std::fs::create_dir_all(&case_dir).unwrap(); + std::fs::write(case_dir.join("analysis_input_v1.json"), "{}").unwrap(); + std::fs::write(case_dir.join("document_v1.md"), "done").unwrap(); + + let (tx, mut rx) = analyze::channel(); + analyze::recovery::scan_and_enqueue(&tmp, &tx).await; + + assert!(rx.try_recv().is_err(), "completed analysis must not re-enqueue"); +} + +// --------------------------------------------------------------------- +// Document view +// --------------------------------------------------------------------- + +#[tokio::test] +async fn document_view_picks_highest_version() { + let config = config_with_llm(unique_tmp("dv"), "http://unused".into()); + let case_id = "11111111-1111-1111-1111-111111111111"; + let case_dir = seed_case(&config.data_path, "dr_a", case_id); + std::fs::write(case_dir.join("document_v1.md"), "alte Version").unwrap(); + std::fs::write(case_dir.join("document_v2.md"), "neue Version v2").unwrap(); + + let app = doctate_server::create_router(config); + let cookie = login(app.clone(), "dr_a").await; + + let resp = app + .oneshot( + Request::builder() + .uri(format!("/web/cases/{case_id}/document")) + .header(header::COOKIE, &cookie) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(resp.status(), StatusCode::OK); + let body = axum::body::to_bytes(resp.into_body(), usize::MAX).await.unwrap(); + let body_str = String::from_utf8(body.to_vec()).unwrap(); + assert!(body_str.contains("neue Version v2"), "expected v2 content"); + assert!(!body_str.contains("alte Version"), "v1 must not leak"); + assert!(body_str.contains("Dokument v2")); +} + +#[tokio::test] +async fn document_view_without_document_returns_404() { + let config = config_with_llm(unique_tmp("dv2"), "http://unused".into()); + let case_id = "11111111-1111-1111-1111-111111111111"; + seed_case(&config.data_path, "dr_a", case_id); + + let app = doctate_server::create_router(config); + let cookie = login(app.clone(), "dr_a").await; + + let resp = app + .oneshot( + Request::builder() + .uri(format!("/web/cases/{case_id}/document")) + .header(header::COOKIE, &cookie) + .body(Body::empty()) + .unwrap(), + ) + .await + .unwrap(); + assert_eq!(resp.status(), StatusCode::NOT_FOUND); +}