Brummel/doctate
1
0
Fork 0
Code Issues 9 Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor analysis file names

Browse Source 
The versioning of analysis input and document files
(`analysis_input_v{N}.json`, `document_v{N}.md`) has been removed. All
analysis inputs will now use `analysis_input.json` and generated
documents will use `document.md`.

This simplifies file management, as there's no longer a need to track
and manage multiple versions of these files within a case directory. The
analysis worker will now overwrite the existing `document.md` if it
exists, ensuring that the latest analysis result is always present. The
`version` field has also been removed from `AnalyzeJob` and
`AnalysisInput`.
This commit is contained in:
Brummel
2026-04-16 01:56:55 +02:00
parent 928c0659c1
commit 8c6b2eeaa4
9 changed files with 111 additions and 281 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/tests/analyze_test.rs
+27 -90
View File
@@ -235,15 +235,14 @@ async fn analyze_case_happy_path_writes_input_and_redirects() {
assert_eq!(resp.status(), StatusCode::SEE_OTHER);
assert_eq!(
resp.headers().get(header::LOCATION).unwrap().to_str().unwrap(),
format!("/web/cases/{case_id}")
"/web/cases"
);
let input_path = case_dir.join("analysis_input_v1.json");
assert!(input_path.exists(), "analysis_input_v1.json missing");
let input_path = case_dir.join("analysis_input.json");
assert!(input_path.exists(), "analysis_input.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");
@@ -284,7 +283,7 @@ async fn analyze_case_skips_blank_transcript_from_recordings() {
let resp = app.oneshot(analyze_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 raw = std::fs::read_to_string(case_dir.join("analysis_input.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");
@@ -301,14 +300,13 @@ async fn analyze_worker_writes_document_via_wiremock() {
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"),
case_dir.join("analysis_input.json"),
serde_json::to_vec_pretty(&input).unwrap(),
)
.unwrap();
@@ -332,16 +330,15 @@ async fn analyze_worker_writes_document_via_wiremock() {
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 document_path = case_dir.join("document.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");
panic!("document.md not written within 5s");
}
tokio::time::sleep(Duration::from_millis(20)).await;
}
@@ -365,13 +362,12 @@ async fn recovery_enqueues_pending_analysis() {
let tmp = unique_tmp("r1");
let case_dir = tmp.join("dr_a/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("analysis_input.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");
}
@@ -381,8 +377,8 @@ async fn recovery_skips_completed_analysis() {
let tmp = unique_tmp("r2");
let case_dir = tmp.join("dr_a/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();
std::fs::write(case_dir.join("analysis_input.json"), "{}").unwrap();
std::fs::write(case_dir.join("document.md"), "done").unwrap();
let (tx, mut rx) = analyze::channel();
analyze::recovery::scan_and_enqueue(&tmp, &tx).await;
@@ -395,12 +391,11 @@ async fn recovery_skips_completed_analysis() {
// ---------------------------------------------------------------------
#[tokio::test]
async fn document_view_picks_highest_version() {
async fn document_view_reads_document() {
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();
std::fs::write(case_dir.join("document.md"), "der Inhalt").unwrap();
let app = doctate_server::create_router(config);
let cookie = login(app.clone(), "dr_a").await;
@@ -418,9 +413,8 @@ async fn document_view_picks_highest_version() {
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"));
assert!(body_str.contains("der Inhalt"), "expected content in body");
assert!(body_str.contains("Dokument"));
}
// ---------------------------------------------------------------------
@@ -428,11 +422,11 @@ async fn document_view_picks_highest_version() {
// ---------------------------------------------------------------------
#[tokio::test]
async fn analyze_writes_v2_when_document_exists() {
async fn analyze_deletes_old_document_and_writes_fresh_input() {
let config = config_with_llm(unique_tmp("rn-5"), "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"), "altes Dokument").unwrap();
std::fs::write(case_dir.join("document.md"), "altes Dokument").unwrap();
seed_recording(&case_dir, "10-00-00", Some("erste Aufnahme"));
seed_recording(&case_dir, "10-05-00", Some("zweite Aufnahme"));
@@ -442,74 +436,17 @@ async fn analyze_writes_v2_when_document_exists() {
let resp = app.oneshot(analyze_request(case_id, &cookie)).await.unwrap();
assert_eq!(resp.status(), StatusCode::SEE_OTHER);
let input_path = case_dir.join("analysis_input_v2.json");
assert!(input_path.exists(), "analysis_input_v2.json missing");
let parsed: Value = serde_json::from_str(&std::fs::read_to_string(&input_path).unwrap()).unwrap();
assert_eq!(parsed["version"], 2);
assert_eq!(parsed["recordings"].as_array().unwrap().len(), 2);
assert!(case_dir.join("document_v1.md").exists());
}
#[tokio::test]
async fn analyze_v2_worker_writes_document_v2_via_wiremock() {
let tmp = unique_tmp("rn-w");
let case_dir = tmp.join("dr_a/11111111-1111-1111-1111-111111111111");
std::fs::create_dir_all(&case_dir).unwrap();
std::fs::write(case_dir.join("document_v1.md"), "alte Version").unwrap();
let input = json!({
"version": 2,
"last_recording_mtime": "2026-04-15T10:00:00Z",
"recordings": [
{ "recorded_at": "2026-04-15T10:00:00Z", "text": "Patient." }
]
});
std::fs::write(
case_dir.join("analysis_input_v2.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": "neue Fassung" } }]
})))
.mount(&mock)
.await;
let config = config_with_llm(tmp.clone(), mock.uri());
let (tx, rx) = analyze::channel();
let busy = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
let handle = tokio::spawn(analyze::worker::run(rx, config, reqwest::Client::new(), busy));
tx.send(analyze::AnalyzeJob {
case_dir: case_dir.clone(),
version: 2,
})
.unwrap();
let doc_v2 = case_dir.join("document_v2.md");
let deadline = std::time::Instant::now() + Duration::from_secs(5);
while !doc_v2.exists() {
if std::time::Instant::now() > deadline {
panic!("document_v2.md not written within 5s");
}
tokio::time::sleep(Duration::from_millis(20)).await;
}
let content = std::fs::read_to_string(&doc_v2).unwrap();
assert!(content.contains("neue Fassung"));
assert_eq!(
std::fs::read_to_string(case_dir.join("document_v1.md")).unwrap(),
"alte Version"
assert!(
!case_dir.join("document.md").exists(),
"old document must be deleted before re-analysis"
);
drop(tx);
let _ = tokio::time::timeout(Duration::from_secs(2), handle).await;
let input_path = case_dir.join("analysis_input.json");
assert!(input_path.exists(), "analysis_input.json missing");
let parsed: Value = serde_json::from_str(&std::fs::read_to_string(&input_path).unwrap()).unwrap();
assert_eq!(parsed["recordings"].as_array().unwrap().len(), 2);
}
// ---------------------------------------------------------------------
// Soft-delete + Undo
// ---------------------------------------------------------------------
@@ -664,8 +601,8 @@ async fn bulk_analyze_processes_each_selected_case() {
.unwrap();
assert_eq!(resp.status(), StatusCode::SEE_OTHER);
assert!(dir_a.join("analysis_input_v1.json").exists());
assert!(dir_b.join("analysis_input_v1.json").exists());
assert!(dir_a.join("analysis_input.json").exists());
assert!(dir_b.join("analysis_input.json").exists());
}
#[tokio::test]
@@ -673,7 +610,7 @@ async fn recovery_skips_deleted_cases() {
let tmp = unique_tmp("rec-del");
let case_dir = tmp.join("dr_a/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("analysis_input.json"), "{}").unwrap();
std::fs::write(
case_dir.join(".deleted"),
r#"{"batch":"00000000-0000-0000-0000-000000000000","deleted_at":"2026-04-15T10:00:00Z"}"#,