[ci]: bugfix in post api test

Author: DriedYellowPeach

src/components/blob_storage.rs

@@ -9,15 +9,15 @@ const COMMENTS_DIR: &str = "comments";
 
 pub struct LocalStorageDriver {
     blob_path: PathBuf,
-    saved: bool,
+    try_saving: bool,
     confirm: bool,
 }
 
 impl LocalStorageDriver {
     pub fn new(blob_path: PathBuf) -> Self {
         Self {
             blob_path,
-            saved: false,
+            try_saving: false,
             confirm: false,
         }
     }
@@ -30,12 +30,12 @@ impl LocalStorageDriver {
         Ok(())
     }
 
-    pub fn confirm(&mut self) {
+    pub fn confirm_saved(&mut self) {
         self.confirm = true;
     }
 
     pub fn post_save_content(&mut self, file_name: &str, content: &str) -> std::io::Result<()> {
-        self.saved = true;
+        self.try_saving = true;
         let path = self.blob_path.join(file_name);
         let mut file = std::fs::File::create(path)?;
         file.write_all(content.as_bytes())?;
@@ -47,7 +47,7 @@ impl LocalStorageDriver {
         file_name: &str,
         attachment: TempFile,
     ) -> std::io::Result<()> {
-        self.saved = true;
+        self.try_saving = true;
         let save_path = self.blob_path.join(file_name);
         fs::copy(attachment.file.path(), save_path)?;
         Ok(())
@@ -61,7 +61,7 @@ impl LocalStorageDriver {
 // TODO: TEST drop log ok
 impl Drop for LocalStorageDriver {
     fn drop(&mut self) {
-        if self.saved && !self.confirm {
+        if self.try_saving && !self.confirm {
             if let Err(e) = fs::remove_dir_all(&self.blob_path) {
                 tracing::error!("Failed to clean up directory {:?}: {:?}", self.blob_path, e);
             }

src/routes/posts/mod.rs

@@ -58,9 +58,9 @@ async fn read_file_to_string(path: &Path) -> Result<String, PostsError> {
 async fn locate_post_content_file(blob: &str, blob_storage: &BlobStorage) -> Option<PathBuf> {
     let post_dir = blob_storage.single_post_dir(blob);
 
-    let mut entries = tokio::fs::read_dir(post_dir)
+    let mut entries = tokio::fs::read_dir(post_dir.clone())
         .await
-        .context("Failed to read post directory")
+        .context(format!("Failed to read post directory: {post_dir:?}"))
         .inspect_err(|e| tracing::error!("{e:?}"))
         .ok()?;
 
@@ -118,7 +118,7 @@ fn persist_post_and_attachments(
         }
     }
 
-    local_driver.confirm();
+    local_driver.confirm_saved();
 
     Ok(())
 }

src/routes/posts/upload.rs

@@ -68,7 +68,7 @@ pub async fn upload_post(
         .context("Failed to commit transaction")
         .inspect_err(|e| tracing::error!("{e:?}"))?;
 
-    Ok(HttpResponse::Ok().json(serde_json::json!(
+    Ok(HttpResponse::Created().json(serde_json::json!(
     {
         "slug": uniq_slug,
         "id": id

tests/api/posts/mod.rs

@@ -9,7 +9,7 @@ use pine_tails::domain::posts::{Post, PostBuilder};
 
 use crate::utils::TestApp;
 
-async fn insert_post(pool: &PgPool, post: &Post) {
+async fn insert_post(pool: &PgPool, post: &Post) -> uuid::Uuid {
     let id = uuid::Uuid::new_v4();
     sqlx::query!(
         "INSERT INTO posts (id, slug, title, content, date, blob) VALUES ($1, $2, $3, $4, $5, $6)",
@@ -23,6 +23,8 @@ async fn insert_post(pool: &PgPool, post: &Post) {
     .execute(pool)
     .await
     .unwrap();
+
+    id
 }
 
 #[tokio::test]
@@ -32,8 +34,16 @@ async fn get_post_with_existing_slug_should_return_ok() {
         .with_title("hello there")
         .with_content("some content");
     let api_addr = format!("{}/posts/slug/hello-there", app.address);
+    let post = pb.build();
 
-    insert_post(&app.db_pool, &pb.build()).await;
+    let id = insert_post(&app.db_pool, &post).await;
+
+    let mut local_driver = app.blob_storage.post_storage_driver(&id.to_string());
+    local_driver.try_init().unwrap();
+    local_driver
+        .post_save_content("hello-there.md", &post.content)
+        .unwrap();
+    local_driver.confirm_saved();
 
     let response = app
         .client

tests/api/utils/mod.rs

@@ -3,6 +3,7 @@ pub mod email_service_mocking;
 use base64::prelude::*;
 use mail_parser::MessageParser;
 use once_cell::sync::Lazy;
+use pine_tails::components::blob_storage::BlobStorage;
 use reqwest::Url;
 use secrecy::ExposeSecret;
 use sqlx::{Connection, Executor, PgConnection, PgPool};
@@ -17,25 +18,14 @@ use pine_tails::startup::prepare::{
 use pine_tails::telemetry::{get_subscriber, init_subscriber, LoggerFormat, LoggerOutbound};
 
 static TRACING: Lazy<()> = Lazy::new(|| {
-    let use_test_log = std::env::var("TEST_LOG").map_or(false, |x| {
-        matches!(x.as_str(), "1" | "true" | "yes" | "TRUE")
-    });
-
-    let valid_levels = ["info", "error", "trace", "warn", "debug"];
-    let level = std::env::var("LOG_LEVEL").ok();
-    let log_level = level
-        .as_deref()
-        .filter(|lvl| valid_levels.contains(lvl))
-        .unwrap_or("error");
+    let use_test_log = std::env::var("TEST_LOG")
+        .is_ok_and(|x| matches!(x.as_str(), "1" | "true" | "yes" | "TRUE"));
 
     let format = LoggerFormat::Pretty;
 
     if use_test_log {
-        let subscriber = get_subscriber(
-            log_level.into(),
-            format,
-            LoggerOutbound::new(std::io::stderr),
-        );
+        let subscriber =
+            get_subscriber("error".into(), format, LoggerOutbound::new(std::io::stderr));
         init_subscriber(subscriber);
     } else {
         let subscriber = get_subscriber("debug".into(), format, LoggerOutbound::new(std::io::sink));
@@ -45,11 +35,15 @@ static TRACING: Lazy<()> = Lazy::new(|| {
 
 pub struct TestApp {
     pub address: String,
-    pub db_pool: PgPool,
-    pub email_server: MockServer,
     pub email_api: String,
     pub refresh_api: String,
     pub client: reqwest::Client,
+    // NOTE: there are two connections to database
+    // one is this db_pool, acting as backdoor of our TEST
+    // the other is created when starting the web server
+    pub db_pool: PgPool,
+    pub email_server: MockServer,
+    pub blob_storage: BlobStorage,
 }
 
 pub struct ConfirmationLinks {
@@ -83,6 +77,10 @@ impl TestApp {
             temp_config
         };
 
+        let span = tracing::info_span!("Spawn test server");
+        let _enter = span.enter();
+        tracing::info!("Spawning server with configuration: {configuration:#?}");
+
         let db_pool = Self::pool_to_uniq_database(&configuration.database).await;
         let test_app = TestApp {
             address,
@@ -93,6 +91,7 @@ impl TestApp {
             email_api,
             refresh_api: token_api,
             client: reqwest::Client::new(),
+            blob_storage: prepare_blob_storage(&configuration).unwrap(),
         };
 
         let kits = Kits::new(