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

refactor: replace delete/undo flow with close/reopen endpoints

Browse Source 
- POST /web/cases/:id/delete renamed to /close; emits CaseClosed.
- New POST /web/cases/:id/reopen removes the marker; emits CaseReopened.
- Bulk action "delete" renamed to "close"; the shared closed_at timestamp
  still groups the selection for future UI features.
- POST /web/cases/undo-delete removed along with summarize_latest_close_group,
  latest_close_timestamp and restore_close_group. Per-case reopen makes
  the group-undo banner obsolete.
- CaseEventKind::CaseDeleted -> CaseClosed, CaseRestored -> CaseReopened.
- Templates updated to Lucide trash-2 icon, German label "Fall schliessen".
- Tests migrated; delete_watermark_test.rs moved to close_watermark_test.rs.
This commit is contained in:
Brummel
2026-04-21 10:43:39 +02:00
parent 9410d6daaa
commit 396565a571
11 changed files with 176 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files
server/tests/analyze_test.rs
+62 -47
View File
@@ -122,10 +122,19 @@ fn analyze_request(case_id: &str, cookie: &str) -> Request<Body> {
.unwrap()
}
fn delete_request(case_id: &str, cookie: &str) -> Request<Body> {
fn close_request(case_id: &str, cookie: &str) -> Request<Body> {
Request::builder()
.method("POST")
.uri(format!("/web/cases/{case_id}/delete"))
.uri(format!("/web/cases/{case_id}/close"))
.header(header::COOKIE, cookie)
.body(Body::empty())
.unwrap()
}
fn reopen_request(case_id: &str, cookie: &str) -> Request<Body> {
Request::builder()
.method("POST")
.uri(format!("/web/cases/{case_id}/reopen"))
.header(header::COOKIE, cookie)
.body(Body::empty())
.unwrap()
@@ -605,12 +614,12 @@ async fn analyze_deletes_old_document_and_writes_fresh_input() {
}
// ---------------------------------------------------------------------
// Soft-delete + Undo
// Close / Reopen
// ---------------------------------------------------------------------
#[tokio::test]
async fn delete_writes_marker_and_redirects() {
let config = config_with_llm(unique_tmp("del-1"), "http://unused".into());
async fn close_writes_marker_and_hides_case() {
let config = config_with_llm(unique_tmp("close-1"), "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"));
@@ -618,7 +627,7 @@ async fn delete_writes_marker_and_redirects() {
let app = doctate_server::create_router(config);
let cookie = login(app.clone(), "dr_a").await;
let resp = app.oneshot(delete_request(case_id, &cookie)).await.unwrap();
let resp = app.oneshot(close_request(case_id, &cookie)).await.unwrap();
assert_eq!(resp.status(), StatusCode::SEE_OTHER);
assert_eq!(
resp.headers()
@@ -639,8 +648,8 @@ async fn delete_writes_marker_and_redirects() {
}
#[tokio::test]
async fn deleted_case_returns_404_on_detail() {
let config = config_with_llm(unique_tmp("del-2"), "http://unused".into());
async fn closed_case_returns_404_on_detail() {
let config = config_with_llm(unique_tmp("close-2"), "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"));
@@ -650,7 +659,7 @@ async fn deleted_case_returns_404_on_detail() {
let resp = app
.clone()
.oneshot(delete_request(case_id, &cookie))
.oneshot(close_request(case_id, &cookie))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::SEE_OTHER);
@@ -669,60 +678,66 @@ async fn deleted_case_returns_404_on_detail() {
}
#[tokio::test]
async fn undo_delete_restores_latest_group_only() {
let config = config_with_llm(unique_tmp("undo-1"), "http://unused".into());
let case_a = "11111111-1111-1111-1111-111111111111";
let case_b = "22222222-2222-2222-2222-222222222222";
let dir_a = seed_case(&config.data_path, "dr_a", case_a);
let dir_b = seed_case(&config.data_path, "dr_a", case_b);
seed_recording(&dir_a, "10-00-00", Some("a"));
seed_recording(&dir_b, "10-05-00", Some("b"));
async fn reopen_removes_marker_and_restores_case() {
let config = config_with_llm(unique_tmp("reopen-1"), "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"));
let app = doctate_server::create_router(config);
let cookie = login(app.clone(), "dr_a").await;
// Two separate close clicks → two distinct close-groups (distinct
// `closed_at` timestamps).
// Close, then reopen via the explicit endpoint.
let _ = app
.clone()
.oneshot(delete_request(case_a, &cookie))
.await
.unwrap();
// `closed_at` is `now_rfc3339()` with whole-second granularity — the
// sleep must cross a second boundary so the two closes land in
// distinct groups.
tokio::time::sleep(Duration::from_millis(1100)).await;
let _ = app
.clone()
.oneshot(delete_request(case_b, &cookie))
.oneshot(close_request(case_id, &cookie))
.await
.unwrap();
assert!(case_dir.join(".closed").exists());
let undo = app
let resp = app
.clone()
.oneshot(reopen_request(case_id, &cookie))
.await
.unwrap();
assert_eq!(resp.status(), StatusCode::SEE_OTHER);
assert!(
!case_dir.join(".closed").exists(),
".closed marker must be gone after reopen"
);
// Case is addressable again at the detail route — no lingering state.
let detail = app
.oneshot(
Request::builder()
.method("POST")
.uri("/web/cases/undo-delete")
.uri(format!("/web/cases/{case_id}"))
.header(header::COOKIE, &cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(undo.status(), StatusCode::SEE_OTHER);
// case_b (latest close) restored, case_a still closed.
assert!(
!dir_b.join(".closed").exists(),
"case_b marker should be gone"
);
assert!(dir_a.join(".closed").exists(), "case_a marker must remain");
assert_eq!(detail.status(), StatusCode::OK);
}
#[tokio::test]
async fn bulk_delete_shares_one_closed_at_timestamp() {
let config = config_with_llm(unique_tmp("bulk-d"), "http://unused".into());
async fn reopen_is_noop_on_open_case() {
let config = config_with_llm(unique_tmp("reopen-2"), "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"));
let app = doctate_server::create_router(config);
let cookie = login(app.clone(), "dr_a").await;
let resp = app.oneshot(reopen_request(case_id, &cookie)).await.unwrap();
assert_eq!(resp.status(), StatusCode::SEE_OTHER);
assert!(!case_dir.join(".closed").exists());
}
#[tokio::test]
async fn bulk_close_shares_one_closed_at_timestamp() {
let config = config_with_llm(unique_tmp("bulk-c"), "http://unused".into());
let case_a = "11111111-1111-1111-1111-111111111111";
let case_b = "22222222-2222-2222-2222-222222222222";
let dir_a = seed_case(&config.data_path, "dr_a", case_a);
@@ -733,7 +748,7 @@ async fn bulk_delete_shares_one_closed_at_timestamp() {
let app = doctate_server::create_router(config);
let cookie = login(app.clone(), "dr_a").await;
let body = format!("action=delete&case_id={case_a}&case_id={case_b}");
let body = format!("action=close&case_id={case_a}&case_id={case_b}");
let resp = app
.oneshot(
Request::builder()
@@ -754,7 +769,7 @@ async fn bulk_delete_shares_one_closed_at_timestamp() {
serde_json::from_str(&std::fs::read_to_string(dir_b.join(".closed")).unwrap()).unwrap();
assert_eq!(
m_a["closed_at"], m_b["closed_at"],
"bulk-delete must share one closed_at timestamp so undo can group them"
"bulk-close must share one closed_at timestamp across its selection"
);
}
@@ -791,8 +806,8 @@ async fn bulk_analyze_processes_each_selected_case() {
}
#[tokio::test]
async fn recovery_skips_deleted_cases() {
let tmp = unique_tmp("rec-del");
async fn recovery_skips_closed_cases() {
let tmp = unique_tmp("rec-closed");
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.json"), "{}").unwrap();
@@ -805,7 +820,7 @@ async fn recovery_skips_deleted_cases() {
let (tx, mut rx) = analyze::channel();
analyze::recovery::scan_and_enqueue(&tmp, &tx).await;
assert!(rx.try_recv().is_err(), "deleted case must not be enqueued");
assert!(rx.try_recv().is_err(), "closed case must not be enqueued");
}
// ---------------------------------------------------------------------
server/tests/case_page_test.rs
+4 -4
View File
@@ -239,8 +239,8 @@ async fn case_page_empty_case_shows_placeholder() {
"empty-case placeholder missing"
);
assert!(
body.contains(&format!(r#"action="/web/cases/{case_id}/delete""#)),
"delete form missing on empty case"
body.contains(&format!(r#"action="/web/cases/{case_id}/close""#)),
"close form missing on empty case"
);
}
@@ -476,7 +476,7 @@ async fn case_recordings_has_no_action_buttons() {
"recordings page must not expose the analyze action"
);
assert!(
!body.contains(&format!(r#"action="/web/cases/{case_id}/delete""#)),
"recordings page must not expose the delete action"
!body.contains(&format!(r#"action="/web/cases/{case_id}/close""#)),
"recordings page must not expose the close action"
);
}
server/tests/delete_watermark_test.rs → server/tests/close_watermark_test.rs
+27 -27
View File
@@ -1,8 +1,8 @@
//! Listen-relevante Mutationen (Einzel-Delete, Undo, Bulk-Delete) müssen
//! den pro-User Watermark bumpen. Sonst bleibt der ETag von
//! Listen-relevante Mutationen (Close, Reopen, Bulk-Close) müssen den
//! pro-User Watermark bumpen. Sonst bleibt der ETag von
//! `/api/oneliners` stehen, jeder Poll liefert 304, und der Client
//! läuft dauerhaft mit einem Marker für einen Fall, den der Server
//! bereits gelöscht hat (ursprünglicher Bugreport: "Polymyalgia
//! bereits geschlossen hat (ursprünglicher Bugreport: "Polymyalgia
//! rheumatica" blieb im Client sichtbar, obwohl im Web-UI bereits
//! gelöscht).
@@ -28,7 +28,7 @@ fn make_user(slug: &str, password_plain: &str) -> User {
fn test_config_with_users(users: Vec<User>) -> Arc<Config> {
let data_path = std::env::temp_dir().join(format!(
"doctate-delete-wm-test-{}-{}",
"doctate-close-wm-test-{}-{}",
std::process::id(),
uuid::Uuid::new_v4()
));
@@ -106,7 +106,7 @@ async fn capture_etag(
}
#[tokio::test]
async fn delete_bumps_watermark() {
async fn close_bumps_watermark() {
let config = test_config_with_users(vec![make_user("dr_a", "s")]);
let data_path = config.data_path.clone();
let case_id = "550e8400-e29b-41d4-a716-446655440000";
@@ -126,13 +126,13 @@ async fn delete_bumps_watermark() {
assert_eq!(s1, StatusCode::OK);
let etag_before = etag_before.expect("server must set ETag");
// Soft-delete via the web handler.
// Close via the web handler.
let del = app
.clone()
.oneshot(
Request::builder()
.method("POST")
.uri(format!("/web/cases/{case_id}/delete"))
.uri(format!("/web/cases/{case_id}/close"))
.header(header::COOKIE, &cookie)
.body(Body::empty())
.unwrap(),
@@ -142,7 +142,7 @@ async fn delete_bumps_watermark() {
assert_eq!(
del.status().as_u16() / 100,
3,
"delete should redirect (3xx)"
"close should redirect (3xx)"
);
// Same If-None-Match now must NOT match — watermark was bumped.
@@ -155,12 +155,12 @@ async fn delete_bumps_watermark() {
let etag_after = etag_after.expect("200 response must set ETag");
assert_ne!(
etag_after, etag_before,
"delete handler must change the per-user ETag"
"close handler must change the per-user ETag"
);
}
#[tokio::test]
async fn undo_delete_bumps_watermark() {
async fn reopen_bumps_watermark() {
let config = test_config_with_users(vec![make_user("dr_a", "s")]);
let data_path = config.data_path.clone();
let case_id = "660e8400-e29b-41d4-a716-446655440000";
@@ -175,49 +175,49 @@ async fn undo_delete_bumps_watermark() {
.unwrap();
let cookie = extract_session_cookie(&login).expect("login should set cookie");
// Delete first so undo has something to restore; grab the post-delete ETag.
// Close first so reopen has something to restore; grab the post-close ETag.
app.clone()
.oneshot(
Request::builder()
.method("POST")
.uri(format!("/web/cases/{case_id}/delete"))
.uri(format!("/web/cases/{case_id}/close"))
.header(header::COOKIE, &cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
let (_, etag_after_delete) = capture_etag(&app, "key-dr_a", None).await;
let etag_after_delete = etag_after_delete.expect("ETag must be set");
let (_, etag_after_close) = capture_etag(&app, "key-dr_a", None).await;
let etag_after_close = etag_after_close.expect("ETag must be set");
// Undo.
let undo = app
// Reopen.
let reopen = app
.clone()
.oneshot(
Request::builder()
.method("POST")
.uri("/web/cases/undo-delete")
.uri(format!("/web/cases/{case_id}/reopen"))
.header(header::COOKIE, &cookie)
.body(Body::empty())
.unwrap(),
)
.await
.unwrap();
assert_eq!(undo.status().as_u16() / 100, 3, "undo should redirect");
assert_eq!(reopen.status().as_u16() / 100, 3, "reopen should redirect");
// Undo must bump again → post-delete ETag becomes stale.
let (s, etag_after_undo) = capture_etag(&app, "key-dr_a", Some(&etag_after_delete)).await;
// Reopen must bump again → post-close ETag becomes stale.
let (s, etag_after_reopen) = capture_etag(&app, "key-dr_a", Some(&etag_after_close)).await;
assert_eq!(
s,
StatusCode::OK,
"undo must change the ETag so clients re-fetch"
"reopen must change the ETag so clients re-fetch"
);
let etag_after_undo = etag_after_undo.expect("200 response must set ETag");
assert_ne!(etag_after_undo, etag_after_delete);
let etag_after_reopen = etag_after_reopen.expect("200 response must set ETag");
assert_ne!(etag_after_reopen, etag_after_close);
}
#[tokio::test]
async fn bulk_delete_bumps_watermark() {
async fn bulk_close_bumps_watermark() {
let config = test_config_with_users(vec![make_user("dr_a", "s")]);
let data_path = config.data_path.clone();
let case_a = "770e8400-e29b-41d4-a716-446655440000";
@@ -237,8 +237,8 @@ async fn bulk_delete_bumps_watermark() {
let (_, etag_before) = capture_etag(&app, "key-dr_a", None).await;
let etag_before = etag_before.expect("ETag must be set");
// Form-encoded bulk delete: action=delete&case_id=a&case_id=b.
let form = format!("action=delete&case_id={case_a}&case_id={case_b}");
// Form-encoded bulk close: action=close&case_id=a&case_id=b.
let form = format!("action=close&case_id={case_a}&case_id={case_b}");
let bulk = app
.clone()
.oneshot(
@@ -255,7 +255,7 @@ async fn bulk_delete_bumps_watermark() {
assert_eq!(bulk.status().as_u16() / 100, 3, "bulk should redirect");
let (s, etag_after) = capture_etag(&app, "key-dr_a", Some(&etag_before)).await;
assert_eq!(s, StatusCode::OK, "bulk-delete must bump the ETag");
assert_eq!(s, StatusCode::OK, "bulk-close must bump the ETag");
let etag_after = etag_after.expect("200 response must set ETag");
assert_ne!(etag_after, etag_before);
}