refactor

backend/tests/correspondents_flow.rs

@@ -0,0 +1,276 @@
+mod common;
+
+use anyhow::Result;
+use common::{acquire_db_lock, body_to_vec, TestApp};
+use serde::Deserialize;
+use serde_json::json;
+use uuid::Uuid;
+
+#[derive(Deserialize)]
+struct DocumentDetail {
+    document: DocumentSummary,
+}
+
+#[derive(Deserialize)]
+struct DocumentSummary {
+    id: Uuid,
+    title: String,
+    #[serde(default)]
+    correspondents: Vec<DocumentCorrespondentSummary>,
+}
+
+#[derive(Deserialize)]
+struct DocumentCorrespondentSummary {
+    id: Uuid,
+    name: String,
+}
+
+#[derive(Deserialize)]
+struct CorrespondentSummary {
+    id: Uuid,
+}
+
+#[derive(Deserialize)]
+struct BulkCorrespondentResult {
+    assigned: usize,
+    removed: usize,
+}
+
+struct TestContext {
+    app: TestApp,
+    token: String,
+    document_ids: Vec<Uuid>,
+    sender_id: Uuid,
+    receiver_id: Uuid,
+}
+
+impl TestContext {
+    const SENDER_NAME: &'static str = "Acme Corp";
+    const RECEIVER_NAME: &'static str = "Bank Ltd";
+
+    async fn new(prefix: &str) -> Result<Self> {
+        let app = TestApp::new().await?;
+        let username = format!("{prefix}_user");
+        let password = format!("{prefix}_pw");
+        app.insert_user(&username, &password, "admin").await?;
+        let token = app.login_token(&username, &password).await?;
+
+        let first_id =
+            upload_document(&app, &token, &format!("{prefix}-one.txt"), b"letter one").await?;
+        let second_id =
+            upload_document(&app, &token, &format!("{prefix}-two.txt"), b"letter two").await?;
+        let sender_id = create_correspondent(&app, &token, Self::SENDER_NAME).await?;
+        let receiver_id = create_correspondent(&app, &token, Self::RECEIVER_NAME).await?;
+
+        Ok(Self {
+            app,
+            token,
+            document_ids: vec![first_id, second_id],
+            sender_id,
+            receiver_id,
+        })
+    }
+
+    async fn assign(&self, correspondent_ids: &[Uuid]) -> Result<BulkCorrespondentResult> {
+        self.assign_with_action(correspondent_ids, None).await
+    }
+
+    async fn assign_with_action(
+        &self,
+        correspondent_ids: &[Uuid],
+        action: Option<&str>,
+    ) -> Result<BulkCorrespondentResult> {
+        let assignments: Vec<_> = correspondent_ids
+            .iter()
+            .map(|id| json!({ "correspondent_id": id }))
+            .collect();
+
+        let mut payload = json!({
+            "document_ids": self.document_ids,
+            "assignments": assignments,
+        });
+
+        if let Some(action) = action {
+            if let Some(obj) = payload.as_object_mut() {
+                obj.insert("action".to_string(), json!(action));
+            }
+        }
+
+        let response = self
+            .app
+            .post_json(
+                "/api/documents/bulk/correspondents",
+                &payload,
+                Some(&self.token),
+            )
+            .await?;
+        assert!(response.status().is_success());
+        let body = body_to_vec(response.into_body()).await?;
+        Ok(serde_json::from_slice(&body)?)
+    }
+
+    async fn fetch_correspondents(
+        &self,
+        document_id: Uuid,
+    ) -> Result<Vec<DocumentCorrespondentSummary>> {
+        let detail = fetch_document_detail(&self.app, &self.token, document_id).await?;
+        Ok(detail.document.correspondents)
+    }
+
+    async fn create_correspondent(&self, name: &str) -> Result<Uuid> {
+        create_correspondent(&self.app, &self.token, name).await
+    }
+}
+
+#[tokio::test]
+async fn bulk_assign_correspondents_adds_new_links() -> Result<()> {
+    let _lock = acquire_db_lock().await;
+    let context = TestContext::new("corresp_add").await?;
+
+    let result = context
+        .assign(&[context.sender_id, context.receiver_id])
+        .await?;
+    assert_eq!(result.assigned, 4);
+    assert_eq!(result.removed, 0);
+
+    for doc_id in &context.document_ids {
+        let correspondents = context.fetch_correspondents(*doc_id).await?;
+        let names: Vec<_> = correspondents
+            .iter()
+            .map(|entry| entry.name.as_str())
+            .collect();
+        assert!(names.contains(&TestContext::SENDER_NAME));
+        assert!(names.contains(&TestContext::RECEIVER_NAME));
+        let ids: Vec<_> = correspondents.iter().map(|entry| entry.id).collect();
+        assert!(ids.contains(&context.sender_id));
+        assert!(ids.contains(&context.receiver_id));
+    }
+
+    context.app.cleanup().await?;
+    Ok(())
+}
+
+#[tokio::test]
+async fn bulk_assign_correspondents_is_idempotent() -> Result<()> {
+    let _lock = acquire_db_lock().await;
+    let context = TestContext::new("corresp_idempotent").await?;
+
+    context
+        .assign(&[context.sender_id, context.receiver_id])
+        .await?;
+    let repeat = context
+        .assign(&[context.sender_id, context.receiver_id])
+        .await?;
+    assert_eq!(repeat.assigned, 0);
+    assert_eq!(repeat.removed, 0);
+
+    context.app.cleanup().await?;
+    Ok(())
+}
+
+#[tokio::test]
+async fn bulk_remove_correspondents_detaches_links() -> Result<()> {
+    let _lock = acquire_db_lock().await;
+    let context = TestContext::new("corresp_remove").await?;
+
+    context
+        .assign(&[context.sender_id, context.receiver_id])
+        .await?;
+    let removal = context
+        .assign_with_action(&[context.sender_id], Some("remove"))
+        .await?;
+    assert_eq!(removal.assigned, 0);
+    assert_eq!(removal.removed, 2);
+
+    for doc_id in &context.document_ids {
+        let correspondents = context.fetch_correspondents(*doc_id).await?;
+        assert_eq!(correspondents.len(), 1);
+        let entry = &correspondents[0];
+        assert_eq!(entry.id, context.receiver_id);
+        assert_eq!(entry.name, TestContext::RECEIVER_NAME);
+    }
+
+    context.app.cleanup().await?;
+    Ok(())
+}
+
+#[tokio::test]
+async fn bulk_assign_correspondents_appends_new_entries() -> Result<()> {
+    let _lock = acquire_db_lock().await;
+    let context = TestContext::new("corresp_append").await?;
+
+    context
+        .assign(&[context.sender_id, context.receiver_id])
+        .await?;
+    context
+        .assign_with_action(&[context.sender_id], Some("remove"))
+        .await?;
+
+    let charlie_name = "Charlie";
+    let charlie_id = context.create_correspondent(charlie_name).await?;
+    let add_result = context.assign(&[charlie_id]).await?;
+    assert_eq!(add_result.assigned, 2);
+    assert_eq!(add_result.removed, 0);
+
+    for doc_id in &context.document_ids {
+        let correspondents = context.fetch_correspondents(*doc_id).await?;
+        assert_eq!(correspondents.len(), 2);
+        let ids: Vec<_> = correspondents.iter().map(|entry| entry.id).collect();
+        assert!(ids.contains(&context.receiver_id));
+        assert!(ids.contains(&charlie_id));
+        let names: Vec<_> = correspondents
+            .iter()
+            .map(|entry| entry.name.as_str())
+            .collect();
+        assert!(names.contains(&TestContext::RECEIVER_NAME));
+        assert!(names.contains(&charlie_name));
+    }
+
+    context.app.cleanup().await?;
+    Ok(())
+}
+
+async fn upload_document(
+    app: &TestApp,
+    token: &str,
+    filename: &str,
+    contents: &[u8],
+) -> Result<Uuid> {
+    let response = app
+        .upload_document(
+            "/api/documents",
+            filename,
+            "text/plain",
+            contents,
+            None,
+            token,
+        )
+        .await?;
+    assert!(response.status().is_success());
+    let body = body_to_vec(response.into_body()).await?;
+    let detail: DocumentDetail = serde_json::from_slice(&body)?;
+    Ok(detail.document.id)
+}
+
+async fn create_correspondent(app: &TestApp, token: &str, name: &str) -> Result<Uuid> {
+    let response = app
+        .post_json("/api/correspondents", &json!({ "name": name }), Some(token))
+        .await?;
+    assert!(response.status().is_success());
+    let body = body_to_vec(response.into_body()).await?;
+    let summary: CorrespondentSummary = serde_json::from_slice(&body)?;
+    Ok(summary.id)
+}
+
+async fn fetch_document_detail(
+    app: &TestApp,
+    token: &str,
+    document_id: Uuid,
+) -> Result<DocumentDetail> {
+    let response = app
+        .get(&format!("/api/documents/{document_id}"), Some(token))
+        .await?;
+    assert!(response.status().is_success());
+    let body = body_to_vec(response.into_body()).await?;
+    Ok(serde_json::from_slice(&body)?)
+}

backend/tests/documents_flow.rs

@@ -83,19 +83,8 @@ struct TagSummary {
 
 #[derive(Deserialize)]
 struct DocumentCorrespondentInfo {
-    name: String,
-    role: String,
-}
-
-#[derive(Deserialize)]
-struct CorrespondentSummary {
     id: Uuid,
-}
-
-#[derive(Deserialize)]
-struct BulkCorrespondentResult {
-    assigned: usize,
-    removed: usize,
+    name: String,
 }
 
 #[derive(Deserialize)]
@@ -809,300 +798,6 @@ async fn bulk_update_tags_for_selection() -> Result<()> {
     Ok(())
 }
 
-#[tokio::test]
-async fn bulk_assign_correspondents_to_selection() -> Result<()> {
-    let _lock = acquire_db_lock().await;
-    let app = TestApp::new().await?;
-
-    let password = "bulkcorresp";
-    app.insert_user("corra", password, "admin").await?;
-    let token = app.login_token("corra", password).await?;
-
-    let first = app
-        .upload_document(
-            "/api/documents",
-            "letter-one.txt",
-            "text/plain",
-            b"letter one",
-            None,
-            &token,
-        )
-        .await?;
-    {
-        let status = first.status();
-        assert!(
-            status == StatusCode::OK
-                || status == StatusCode::CREATED
-                || status == StatusCode::NO_CONTENT
-        );
-    }
-    let first_body = body_to_vec(first.into_body()).await?;
-    let first_detail: DocumentDetail = serde_json::from_slice(&first_body)?;
-
-    let second = app
-        .upload_document(
-            "/api/documents",
-            "letter-two.txt",
-            "text/plain",
-            b"letter two",
-            None,
-            &token,
-        )
-        .await?;
-    {
-        let status = second.status();
-        assert!(
-            status == StatusCode::OK
-                || status == StatusCode::CREATED
-                || status == StatusCode::NO_CONTENT
-        );
-    }
-    let second_body = body_to_vec(second.into_body()).await?;
-    let second_detail: DocumentDetail = serde_json::from_slice(&second_body)?;
-
-    let sender = app
-        .post_json(
-            "/api/correspondents",
-            &serde_json::json!({ "name": "Acme Corp" }),
-            Some(&token),
-        )
-        .await?;
-    {
-        let status = sender.status();
-        assert!(
-            status == StatusCode::OK
-                || status == StatusCode::CREATED
-                || status == StatusCode::NO_CONTENT
-        );
-    }
-    let sender_body = body_to_vec(sender.into_body()).await?;
-    let sender_summary: CorrespondentSummary = serde_json::from_slice(&sender_body)?;
-
-    let receiver = app
-        .post_json(
-            "/api/correspondents",
-            &serde_json::json!({ "name": "Bank Ltd" }),
-            Some(&token),
-        )
-        .await?;
-    {
-        let status = receiver.status();
-        assert!(
-            status == StatusCode::OK
-                || status == StatusCode::CREATED
-                || status == StatusCode::NO_CONTENT
-        );
-    }
-    let receiver_body = body_to_vec(receiver.into_body()).await?;
-    let receiver_summary: CorrespondentSummary = serde_json::from_slice(&receiver_body)?;
-
-    let assign_payload = serde_json::json!({
-        "document_ids": [
-            first_detail.document.id,
-            second_detail.document.id
-        ],
-        "assignments": [
-            {
-                "correspondent_id": sender_summary.id,
-                "role": "sender"
-            },
-            {
-                "correspondent_id": receiver_summary.id,
-                "role": "receiver"
-            }
-        ]
-    });
-
-    let assign_resp = app
-        .post_json(
-            "/api/documents/bulk/correspondents",
-            &assign_payload,
-            Some(&token),
-        )
-        .await?;
-    {
-        let status = assign_resp.status();
-        assert!(
-            status == StatusCode::OK
-                || status == StatusCode::CREATED
-                || status == StatusCode::NO_CONTENT
-        );
-    }
-    let assign_body = body_to_vec(assign_resp.into_body()).await?;
-    let assign_result: BulkCorrespondentResult = serde_json::from_slice(&assign_body)?;
-    assert_eq!(assign_result.assigned, 4);
-    assert_eq!(assign_result.removed, 0);
-
-    for doc_id in [first_detail.document.id, second_detail.document.id] {
-        let refreshed = app
-            .get(&format!("/api/documents/{doc_id}"), Some(&token))
-            .await?;
-        {
-            let status = refreshed.status();
-            assert!(status == StatusCode::OK || status == StatusCode::CREATED);
-        }
-        let refreshed_body = body_to_vec(refreshed.into_body()).await?;
-        let detail: DocumentDetail = serde_json::from_slice(&refreshed_body)?;
-        assert_eq!(detail.document.correspondents.len(), 2);
-        assert!(detail
-            .document
-            .correspondents
-            .iter()
-            .any(|entry| entry.role == "sender" && entry.name == "Acme Corp"));
-        assert!(detail
-            .document
-            .correspondents
-            .iter()
-            .any(|entry| entry.role == "receiver" && entry.name == "Bank Ltd"));
-    }
-
-    let duplicate_resp = app
-        .post_json(
-            "/api/documents/bulk/correspondents",
-            &assign_payload,
-            Some(&token),
-        )
-        .await?;
-    {
-        let status = duplicate_resp.status();
-        assert!(
-            status == StatusCode::OK
-                || status == StatusCode::CREATED
-                || status == StatusCode::NO_CONTENT
-        );
-    }
-    let duplicate_body = body_to_vec(duplicate_resp.into_body()).await?;
-    let duplicate_result: BulkCorrespondentResult = serde_json::from_slice(&duplicate_body)?;
-    assert_eq!(duplicate_result.assigned, 0);
-    assert_eq!(duplicate_result.removed, 0);
-
-    let replacement = app
-        .post_json(
-            "/api/correspondents",
-            &serde_json::json!({ "name": "Charlie" }),
-            Some(&token),
-        )
-        .await?;
-    {
-        let status = replacement.status();
-        assert!(
-            status == StatusCode::OK
-                || status == StatusCode::CREATED
-                || status == StatusCode::NO_CONTENT
-        );
-    }
-    let replacement_body = body_to_vec(replacement.into_body()).await?;
-    let replacement_summary: CorrespondentSummary = serde_json::from_slice(&replacement_body)?;
-
-    let replace_payload = serde_json::json!({
-        "document_ids": [
-            first_detail.document.id,
-            second_detail.document.id
-        ],
-        "assignments": [
-            {
-                "correspondent_id": replacement_summary.id,
-                "role": "sender"
-            }
-        ]
-    });
-
-    let replace_resp = app
-        .post_json(
-            "/api/documents/bulk/correspondents",
-            &replace_payload,
-            Some(&token),
-        )
-        .await?;
-    {
-        let status = replace_resp.status();
-        assert!(
-            status == StatusCode::OK
-                || status == StatusCode::CREATED
-                || status == StatusCode::NO_CONTENT
-        );
-    }
-    let replace_body = body_to_vec(replace_resp.into_body()).await?;
-    let replace_result: BulkCorrespondentResult = serde_json::from_slice(&replace_body)?;
-    assert_eq!(replace_result.assigned, 2);
-    assert_eq!(replace_result.removed, 2);
-
-    for doc_id in [first_detail.document.id, second_detail.document.id] {
-        let refreshed = app
-            .get(&format!("/api/documents/{doc_id}"), Some(&token))
-            .await?;
-        let refreshed_body = body_to_vec(refreshed.into_body()).await?;
-        let detail: DocumentDetail = serde_json::from_slice(&refreshed_body)?;
-        assert_eq!(detail.document.correspondents.len(), 2);
-        assert!(detail
-            .document
-            .correspondents
-            .iter()
-            .any(|entry| entry.role == "sender" && entry.name == "Charlie"));
-        assert!(detail
-            .document
-            .correspondents
-            .iter()
-            .any(|entry| entry.role == "receiver" && entry.name == "Bank Ltd"));
-    }
-
-    let remove_payload = serde_json::json!({
-        "document_ids": [
-            first_detail.document.id,
-            second_detail.document.id
-        ],
-        "assignments": [
-            {
-                "correspondent_id": receiver_summary.id,
-                "role": "receiver"
-            }
-        ],
-        "action": "remove"
-    });
-
-    let remove_resp = app
-        .post_json(
-            "/api/documents/bulk/correspondents",
-            &remove_payload,
-            Some(&token),
-        )
-        .await?;
-    {
-        let status = remove_resp.status();
-        assert!(
-            status == StatusCode::OK
-                || status == StatusCode::CREATED
-                || status == StatusCode::NO_CONTENT
-        );
-    }
-    let remove_body = body_to_vec(remove_resp.into_body()).await?;
-    let remove_result: BulkCorrespondentResult = serde_json::from_slice(&remove_body)?;
-    assert_eq!(remove_result.assigned, 0);
-    assert_eq!(remove_result.removed, 2);
-
-    for doc_id in [first_detail.document.id, second_detail.document.id] {
-        let refreshed = app
-            .get(&format!("/api/documents/{doc_id}"), Some(&token))
-            .await?;
-        let refreshed_body = body_to_vec(refreshed.into_body()).await?;
-        let detail: DocumentDetail = serde_json::from_slice(&refreshed_body)?;
-        assert_eq!(detail.document.correspondents.len(), 1);
-        assert!(detail
-            .document
-            .correspondents
-            .iter()
-            .any(|entry| entry.role == "sender" && entry.name == "Charlie"));
-        assert!(!detail
-            .document
-            .correspondents
-            .iter()
-            .any(|entry| entry.role == "receiver"));
-    }
-
-    app.cleanup().await?;
-    Ok(())
-}
-
 #[tokio::test]
 async fn bulk_reanalyze_selected_documents() -> Result<()> {
     let _lock = acquire_db_lock().await;
@@ -1803,6 +1498,7 @@ async fn list_document_versions_and_fetch_detail() -> Result<()> {
     let versions: Vec<DocumentVersionListItem> = serde_json::from_slice(&list_body)?;
     assert_eq!(versions.len(), 1);
     assert_eq!(versions[0].id, version_id);
+    assert_eq!(versions[0].version_number, 1);
 
     let detail_resp = app
         .get(