preview-stack

backend/tests/documents_flow.rs

@@ -3,8 +3,7 @@ mod common;
 use anyhow::Result;
 use axum::http::StatusCode;
 use common::{acquire_db_lock, body_to_vec, TestApp};
-use serde::Deserialize;
-use serde_json::Value;
+use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 #[derive(Deserialize)]
@@ -17,10 +16,12 @@ struct DocumentDetail {
 #[derive(Deserialize)]
 struct DocumentInfo {
     id: Uuid,
+    title: String,
     original_name: String,
     current_version: i32,
     deleted_at: Option<String>,
-    tags: Vec<Value>,
+    issued_at: Option<String>,
+    tags: Vec<TagSummary>,
 }
 
 #[derive(Deserialize)]
@@ -30,6 +31,7 @@ struct DocumentVersion {
     size_bytes: i64,
 }
 
+#[allow(dead_code)]
 #[derive(Deserialize)]
 struct DocumentAssetInfo {
     id: Uuid,
@@ -53,6 +55,22 @@ struct BulkReanalyze {
     queued: usize,
 }
 
+#[derive(Deserialize)]
+struct BulkMoveResult {
+    updated: usize,
+}
+
+#[derive(Deserialize)]
+struct BulkTagResult {
+    added: usize,
+    removed: usize,
+}
+
+#[derive(Deserialize)]
+struct TagSummary {
+    label: String,
+}
+
 #[derive(Deserialize)]
 struct AnalyzeJobPayload {
     document_id: Uuid,
@@ -61,6 +79,51 @@ struct AnalyzeJobPayload {
     force: bool,
 }
 
+#[derive(Deserialize)]
+struct FolderResponse {
+    folder: FolderInfo,
+}
+
+#[derive(Deserialize)]
+struct FolderInfo {
+    id: Uuid,
+}
+
+#[derive(Deserialize)]
+struct FolderContents {
+    documents: Vec<DocumentListItem>,
+}
+
+#[derive(Deserialize)]
+struct TagResponse {
+    id: Uuid,
+}
+
+#[derive(Serialize)]
+struct BulkMoveRequest<'a> {
+    document_ids: &'a [Uuid],
+    folder_id: Option<Uuid>,
+}
+
+#[derive(Serialize)]
+struct BulkTagRequest<'a> {
+    document_ids: &'a [Uuid],
+    tag_ids: &'a [Uuid],
+    action: &'a str,
+}
+
+#[derive(Serialize)]
+struct CreateFolderRequest<'a> {
+    name: &'a str,
+    parent_id: Option<Uuid>,
+}
+
+#[derive(Serialize)]
+struct CreateTagPayload<'a> {
+    label: &'a str,
+    color: Option<&'a str>,
+}
+
 #[tokio::test]
 async fn upload_and_list_document() -> Result<()> {
     let _lock = acquire_db_lock().await;
@@ -86,8 +149,10 @@ async fn upload_and_list_document() -> Result<()> {
     let detail: DocumentDetail = serde_json::from_slice(&body)?;
 
     assert_eq!(detail.document.original_name, "doc.txt");
+    assert_eq!(detail.document.title, "doc");
     assert_eq!(detail.document.current_version, 1);
     assert_eq!(detail.document.deleted_at, None);
+    assert!(detail.document.issued_at.is_none());
     assert!(detail.document.tags.is_empty());
     assert_eq!(detail.current_version.size_bytes, file_bytes.len() as i64);
     assert!(detail.assets.is_empty());
@@ -273,3 +338,323 @@ async fn bulk_reanalyze_documents() -> Result<()> {
     app.cleanup().await?;
     Ok(())
 }
+
+#[tokio::test]
+async fn bulk_move_documents_to_folder() -> Result<()> {
+    let _lock = acquire_db_lock().await;
+    let app = TestApp::new().await?;
+
+    let password = "bulkmove";
+    app.insert_user("mover", password, "admin").await?;
+    let token = app.login_token("mover", password).await?;
+
+    let alpha = app
+        .upload_document(
+            "/api/documents",
+            "alpha.txt",
+            "text/plain",
+            b"alpha",
+            None,
+            &token,
+        )
+        .await?;
+    assert_eq!(alpha.status(), StatusCode::CREATED);
+    let alpha_body = body_to_vec(alpha.into_body()).await?;
+    let alpha_detail: DocumentDetail = serde_json::from_slice(&alpha_body)?;
+
+    let beta = app
+        .upload_document(
+            "/api/documents",
+            "beta.txt",
+            "text/plain",
+            b"beta",
+            None,
+            &token,
+        )
+        .await?;
+    assert_eq!(beta.status(), StatusCode::CREATED);
+    let beta_body = body_to_vec(beta.into_body()).await?;
+    let beta_detail: DocumentDetail = serde_json::from_slice(&beta_body)?;
+
+    let folder_resp = app
+        .post_json(
+            "/api/folders",
+            &CreateFolderRequest {
+                name: "Archives",
+                parent_id: None,
+            },
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(folder_resp.status(), StatusCode::OK);
+    let folder_body = body_to_vec(folder_resp.into_body()).await?;
+    let folder: FolderResponse = serde_json::from_slice(&folder_body)?;
+
+    let move_resp = app
+        .post_json(
+            "/api/documents/bulk/move",
+            &BulkMoveRequest {
+                document_ids: &[alpha_detail.document.id, beta_detail.document.id],
+                folder_id: Some(folder.folder.id),
+            },
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(move_resp.status(), StatusCode::OK);
+    let move_body = body_to_vec(move_resp.into_body()).await?;
+    let result: BulkMoveResult = serde_json::from_slice(&move_body)?;
+    assert_eq!(result.updated, 2);
+
+    let folder_contents = app
+        .get(
+            &format!("/api/folders/{}/contents", folder.folder.id),
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(folder_contents.status(), StatusCode::OK);
+    let folder_body = body_to_vec(folder_contents.into_body()).await?;
+    let folder_docs: FolderContents = serde_json::from_slice(&folder_body)?;
+    let moved_ids: Vec<_> = folder_docs.documents.iter().map(|doc| doc.id).collect();
+    assert!(moved_ids.contains(&alpha_detail.document.id));
+    assert!(moved_ids.contains(&beta_detail.document.id));
+
+    let root_contents = app.get("/api/folders/root/contents", Some(&token)).await?;
+    let root_body = body_to_vec(root_contents.into_body()).await?;
+    let root_docs: FolderContents = serde_json::from_slice(&root_body)?;
+    assert!(root_docs
+        .documents
+        .iter()
+        .all(|doc| doc.id != alpha_detail.document.id && doc.id != beta_detail.document.id));
+
+    app.cleanup().await?;
+    Ok(())
+}
+
+#[tokio::test]
+async fn bulk_update_tags_for_selection() -> Result<()> {
+    let _lock = acquire_db_lock().await;
+    let app = TestApp::new().await?;
+
+    let password = "bulktags";
+    app.insert_user("tagger", password, "admin").await?;
+    let token = app.login_token("tagger", password).await?;
+
+    let first = app
+        .upload_document(
+            "/api/documents",
+            "notes.txt",
+            "text/plain",
+            b"notes",
+            None,
+            &token,
+        )
+        .await?;
+    assert_eq!(first.status(), StatusCode::CREATED);
+    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",
+            "report.txt",
+            "text/plain",
+            b"report",
+            None,
+            &token,
+        )
+        .await?;
+    assert_eq!(second.status(), StatusCode::CREATED);
+    let second_body = body_to_vec(second.into_body()).await?;
+    let second_detail: DocumentDetail = serde_json::from_slice(&second_body)?;
+
+    let urgent_tag = app
+        .post_json(
+            "/api/tags",
+            &CreateTagPayload {
+                label: "Urgent",
+                color: None,
+            },
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(urgent_tag.status(), StatusCode::OK);
+    let urgent_body = body_to_vec(urgent_tag.into_body()).await?;
+    let urgent: TagResponse = serde_json::from_slice(&urgent_body)?;
+
+    let review_tag = app
+        .post_json(
+            "/api/tags",
+            &CreateTagPayload {
+                label: "Review",
+                color: None,
+            },
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(review_tag.status(), StatusCode::OK);
+    let review_body = body_to_vec(review_tag.into_body()).await?;
+    let review: TagResponse = serde_json::from_slice(&review_body)?;
+
+    let add_resp = app
+        .post_json(
+            "/api/documents/bulk/tags",
+            &BulkTagRequest {
+                document_ids: &[first_detail.document.id, second_detail.document.id],
+                tag_ids: &[urgent.id, review.id],
+                action: "add",
+            },
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(add_resp.status(), StatusCode::OK);
+    let add_body = body_to_vec(add_resp.into_body()).await?;
+    let add_result: BulkTagResult = serde_json::from_slice(&add_body)?;
+    assert_eq!(add_result.added, 4);
+
+    for doc_id in [&first_detail.document.id, &second_detail.document.id] {
+        let refreshed = app
+            .get(&format!("/api/documents/{}", doc_id), Some(&token))
+            .await?;
+        assert_eq!(refreshed.status(), StatusCode::OK);
+        let refreshed_body = body_to_vec(refreshed.into_body()).await?;
+        let detail: DocumentDetail = serde_json::from_slice(&refreshed_body)?;
+        let labels: Vec<_> = detail
+            .document
+            .tags
+            .iter()
+            .map(|tag| tag.label.as_str())
+            .collect();
+        assert!(labels.contains(&"Urgent"));
+        assert!(labels.contains(&"Review"));
+    }
+
+    let remove_resp = app
+        .post_json(
+            "/api/documents/bulk/tags",
+            &BulkTagRequest {
+                document_ids: &[first_detail.document.id, second_detail.document.id],
+                tag_ids: &[urgent.id],
+                action: "remove",
+            },
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(remove_resp.status(), StatusCode::OK);
+    let remove_body = body_to_vec(remove_resp.into_body()).await?;
+    let remove_result: BulkTagResult = serde_json::from_slice(&remove_body)?;
+    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)?;
+        let labels: Vec<_> = detail
+            .document
+            .tags
+            .iter()
+            .map(|tag| tag.label.as_str())
+            .collect();
+        assert!(!labels.contains(&"Urgent"));
+        assert!(labels.contains(&"Review"));
+    }
+
+    app.cleanup().await?;
+    Ok(())
+}
+
+#[tokio::test]
+async fn bulk_reanalyze_selected_documents() -> Result<()> {
+    let _lock = acquire_db_lock().await;
+    let app = TestApp::new().await?;
+
+    let password = "subsetrean";
+    app.insert_user("subset", password, "admin").await?;
+    let token = app.login_token("subset", password).await?;
+
+    app.clear_jobs().await?;
+
+    let first = app
+        .upload_document(
+            "/api/documents",
+            "doc-one.txt",
+            "text/plain",
+            b"one",
+            None,
+            &token,
+        )
+        .await?;
+    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",
+            "doc-two.txt",
+            "text/plain",
+            b"two",
+            None,
+            &token,
+        )
+        .await?;
+    let second_body = body_to_vec(second.into_body()).await?;
+    let second_detail: DocumentDetail = serde_json::from_slice(&second_body)?;
+
+    let third = app
+        .upload_document(
+            "/api/documents",
+            "doc-three.txt",
+            "text/plain",
+            b"three",
+            None,
+            &token,
+        )
+        .await?;
+    let third_body = body_to_vec(third.into_body()).await?;
+    let third_detail: DocumentDetail = serde_json::from_slice(&third_body)?;
+
+    app.clear_jobs().await?;
+
+    let response = app
+        .post_json(
+            "/api/documents/bulk/reanalyze",
+            &serde_json::json!({
+                "document_ids": [
+                    first_detail.document.id,
+                    third_detail.document.id
+                ],
+                "force": true
+            }),
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(response.status(), StatusCode::ACCEPTED);
+    let body = body_to_vec(response.into_body()).await?;
+    let bulk: BulkReanalyze = serde_json::from_slice(&body)?;
+    assert_eq!(bulk.queued, 2);
+
+    let jobs = app.jobs_by_type("analyze-document").await?;
+    assert_eq!(jobs.len(), 2);
+    let mut payload_docs = Vec::new();
+    for job in jobs {
+        let payload: AnalyzeJobPayload = serde_json::from_value(job.payload)?;
+        assert!(payload.force);
+        payload_docs.push((payload.document_id, payload.document_version_id));
+    }
+
+    assert!(payload_docs
+        .iter()
+        .all(|(doc_id, _)| *doc_id != second_detail.document.id));
+
+    let mut expected = vec![
+        (first_detail.document.id, first_detail.current_version.id),
+        (third_detail.document.id, third_detail.current_version.id),
+    ];
+    payload_docs.sort();
+    expected.sort();
+    assert_eq!(payload_docs, expected);
+
+    app.cleanup().await?;
+    Ok(())
+}