tests

backend/tests/documents_flow.rs

@@ -0,0 +1,177 @@
+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 uuid::Uuid;
+
+#[derive(Deserialize)]
+struct DocumentDetail {
+    document: DocumentInfo,
+    current_version: DocumentVersion,
+}
+
+#[derive(Deserialize)]
+struct DocumentInfo {
+    id: Uuid,
+    original_name: String,
+    current_version: i32,
+    deleted_at: Option<String>,
+    tags: Vec<Value>,
+}
+
+#[derive(Deserialize)]
+struct DocumentVersion {
+    s3_key: String,
+    size_bytes: i64,
+}
+
+#[derive(Deserialize)]
+struct DocumentListItem {
+    id: Uuid,
+    current_version: i32,
+}
+
+#[derive(Deserialize)]
+struct DocumentDownload {
+    url: String,
+    filename: String,
+}
+
+#[tokio::test]
+async fn upload_and_list_document() -> Result<()> {
+    let _lock = acquire_db_lock().await;
+    let Some(app) = TestApp::new().await? else {
+        eprintln!("skipping test: TEST_DATABASE_URL not set");
+        return Ok(());
+    };
+
+    let password = "passw0rd";
+    app.insert_user("dana", password, "admin").await?;
+    let token = app.login_token("dana", password).await?;
+
+    let file_bytes = b"example document body".to_vec();
+    let upload = app
+        .upload_document(
+            "/api/documents",
+            "doc.txt",
+            "text/plain",
+            &file_bytes,
+            None,
+            &token,
+        )
+        .await?;
+    assert_eq!(upload.status(), StatusCode::OK);
+    let body = body_to_vec(upload.into_body()).await?;
+    let detail: DocumentDetail = serde_json::from_slice(&body)?;
+
+    assert_eq!(detail.document.original_name, "doc.txt");
+    assert_eq!(detail.document.current_version, 1);
+    assert_eq!(detail.document.deleted_at, None);
+    assert!(detail.document.tags.is_empty());
+    assert_eq!(detail.current_version.size_bytes, file_bytes.len() as i64);
+
+    let stored = app
+        .storage()
+        .get(&detail.current_version.s3_key)
+        .await
+        .expect("object stored");
+    assert_eq!(stored.bytes, file_bytes);
+
+    let response = app.get("/api/documents", Some(&token)).await?;
+    assert_eq!(response.status(), StatusCode::OK);
+    let body = body_to_vec(response.into_body()).await?;
+    let mut list: Vec<DocumentListItem> = serde_json::from_slice(&body)?;
+    assert_eq!(list.len(), 1);
+    let item = list.pop().unwrap();
+    assert_eq!(item.id, detail.document.id);
+    assert_eq!(item.current_version, 1);
+
+    let download = app
+        .get(
+            &format!("/api/documents/{}/download", detail.document.id),
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(download.status(), StatusCode::OK);
+    let body = body_to_vec(download.into_body()).await?;
+    let download_info: DocumentDownload = serde_json::from_slice(&body)?;
+    assert!(download_info.url.contains(&detail.current_version.s3_key));
+    assert_eq!(download_info.filename, "doc.txt");
+
+    app.cleanup().await?;
+    Ok(())
+}
+
+#[tokio::test]
+async fn duplicate_and_restore_document() -> Result<()> {
+    let _lock = acquire_db_lock().await;
+    let Some(app) = TestApp::new().await? else {
+        eprintln!("skipping test: TEST_DATABASE_URL not set");
+        return Ok(());
+    };
+
+    let password = "pass1234";
+    app.insert_user("sam", password, "admin").await?;
+    let token = app.login_token("sam", password).await?;
+
+    let payload = b"same bytes".to_vec();
+    let first = app
+        .upload_document(
+            "/api/documents",
+            "dup.bin",
+            "application/octet-stream",
+            &payload,
+            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",
+            "dup.bin",
+            "application/octet-stream",
+            &payload,
+            None,
+            &token,
+        )
+        .await?;
+    assert_eq!(second.status(), StatusCode::OK);
+    let second_body = body_to_vec(second.into_body()).await?;
+    let second_detail: DocumentDetail = serde_json::from_slice(&second_body)?;
+
+    assert_eq!(first_detail.document.id, second_detail.document.id);
+    assert_eq!(second_detail.document.deleted_at, None);
+
+    let delete = app
+        .delete(
+            &format!("/api/documents/{}", first_detail.document.id),
+            Some(&token),
+        )
+        .await?;
+    assert_eq!(delete.status(), StatusCode::NO_CONTENT);
+
+    let third = app
+        .upload_document(
+            "/api/documents",
+            "dup.bin",
+            "application/octet-stream",
+            &payload,
+            None,
+            &token,
+        )
+        .await?;
+    let third_body = body_to_vec(third.into_body()).await?;
+    let third_detail: DocumentDetail = serde_json::from_slice(&third_body)?;
+
+    assert_eq!(third_detail.document.id, first_detail.document.id);
+    assert_eq!(third_detail.document.deleted_at, None);
+
+    app.cleanup().await?;
+    Ok(())
+}