feat: enhance error handling and user follow functionality, update tests for user context

thoughts-backend/tests/api/feed.rs

@@ -13,7 +13,7 @@ async fn test_feed_and_user_thoughts() {
 
     // As user1, post a thought
     let body = json!({ "content": "A thought from user1" }).to_string();
-    make_post_request(app.router.clone(), "/thoughts", body).await;
+    make_post_request(app.router.clone(), "/thoughts", body, Some(1)).await;
 
     // As a different "user", create thoughts for user2 and user3 (we cheat here since auth is hardcoded)
     app::persistence::thought::create_thought(
@@ -36,7 +36,7 @@ async fn test_feed_and_user_thoughts() {
     .unwrap();
 
     // 1. Get thoughts for user2 - should only see their thought
-    let response = make_get_request(app.router.clone(), "/users/user2/thoughts").await;
+    let response = make_get_request(app.router.clone(), "/users/user2/thoughts", Some(2)).await;
     assert_eq!(response.status(), StatusCode::OK);
     let body = response.into_body().collect().await.unwrap().to_bytes();
     let v: serde_json::Value = serde_json::from_slice(&body).unwrap();
@@ -44,17 +44,23 @@ async fn test_feed_and_user_thoughts() {
     assert_eq!(v["thoughts"][0]["content"], "user2 was here");
 
     // 2. user1's feed is initially empty
-    let response = make_get_request(app.router.clone(), "/feed").await;
+    let response = make_get_request(app.router.clone(), "/feed", Some(1)).await;
     assert_eq!(response.status(), StatusCode::OK);
     let body = response.into_body().collect().await.unwrap().to_bytes();
     let v: serde_json::Value = serde_json::from_slice(&body).unwrap();
     assert!(v["thoughts"].as_array().unwrap().is_empty());
 
     // 3. user1 follows user2
-    make_post_request(app.router.clone(), "/users/user2/follow", "".to_string()).await;
+    make_post_request(
+        app.router.clone(),
+        "/users/user2/follow",
+        "".to_string(),
+        Some(1),
+    )
+    .await;
 
     // 4. user1's feed now has user2's thought
-    let response = make_get_request(app.router.clone(), "/feed").await;
+    let response = make_get_request(app.router.clone(), "/feed", Some(1)).await;
     assert_eq!(response.status(), StatusCode::OK);
     let body = response.into_body().collect().await.unwrap().to_bytes();
     let v: serde_json::Value = serde_json::from_slice(&body).unwrap();

thoughts-backend/tests/api/follow.rs

@@ -9,25 +9,40 @@ async fn test_follow_endpoints() {
     create_test_user(&app.db, "user2").await;
 
     // 1. user1 follows user2
-    let response =
-        make_post_request(app.router.clone(), "/users/user2/follow", "".to_string()).await;
+    let response = make_post_request(
+        app.router.clone(),
+        "/users/user2/follow",
+        "".to_string(),
+        None,
+    )
+    .await;
     assert_eq!(response.status(), StatusCode::NO_CONTENT);
 
     // 2. user1 tries to follow user2 again (should fail)
-    let response =
-        make_post_request(app.router.clone(), "/users/user2/follow", "".to_string()).await;
-    assert_eq!(response.status(), StatusCode::CONFLICT);
+    let response = make_post_request(
+        app.router.clone(),
+        "/users/user2/follow",
+        "".to_string(),
+        None,
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
 
     // 3. user1 tries to follow a non-existent user
-    let response =
-        make_post_request(app.router.clone(), "/users/nobody/follow", "".to_string()).await;
+    let response = make_post_request(
+        app.router.clone(),
+        "/users/nobody/follow",
+        "".to_string(),
+        None,
+    )
+    .await;
     assert_eq!(response.status(), StatusCode::NOT_FOUND);
 
     // 4. user1 unfollows user2
-    let response = make_delete_request(app.router.clone(), "/users/user2/follow").await;
+    let response = make_delete_request(app.router.clone(), "/users/user2/follow", None).await;
     assert_eq!(response.status(), StatusCode::NO_CONTENT);
 
     // 5. user1 tries to unfollow user2 again (should fail)
-    let response = make_delete_request(app.router.clone(), "/users/user2/follow").await;
+    let response = make_delete_request(app.router.clone(), "/users/user2/follow", None).await;
     assert_eq!(response.status(), StatusCode::NOT_FOUND);
 }

thoughts-backend/tests/api/root.rs

@@ -1,12 +0,0 @@
-use axum::{http::StatusCode, Router};
-use http_body_util::BodyExt;
-
-use utils::testing::make_get_request;
-
-pub(super) async fn test_root(app: Router) {
-    let response = make_get_request(app, "/").await;
-    assert_eq!(response.status(), StatusCode::OK);
-
-    let body = response.into_body().collect().await.unwrap().to_bytes();
-    assert_eq!(&body[..], b"Hello, World from DB!");
-}

thoughts-backend/tests/api/thought.rs

@@ -12,7 +12,7 @@ async fn test_thought_endpoints() {
 
     // 1. Post a new thought as user 1
     let body = json!({ "content": "My first thought!" }).to_string();
-    let response = make_post_request(app.router.clone(), "/thoughts", body).await;
+    let response = make_post_request(app.router.clone(), "/thoughts", body, Some(1)).await;
     assert_eq!(response.status(), StatusCode::CREATED);
     let body = response.into_body().collect().await.unwrap().to_bytes();
     let v: serde_json::Value = serde_json::from_slice(&body).unwrap();
@@ -22,15 +22,20 @@ async fn test_thought_endpoints() {
 
     // 2. Post a thought with invalid content
     let body = json!({ "content": "" }).to_string(); // Too short
-    let response = make_post_request(app.router.clone(), "/thoughts", body).await;
+    let response = make_post_request(app.router.clone(), "/thoughts", body, Some(1)).await;
     assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
 
     // 3. Attempt to delete another user's thought (user1 tries to delete a non-existent thought, but let's pretend it's user2's)
-    let response = make_delete_request(app.router.clone(), &format!("/thoughts/999")).await;
+    let response =
+        make_delete_request(app.router.clone(), &format!("/thoughts/999"), Some(1)).await;
     assert_eq!(response.status(), StatusCode::NOT_FOUND);
 
     // 4. Delete the thought created in step 1
-    let response =
-        make_delete_request(app.router.clone(), &format!("/thoughts/{}", thought_id)).await;
+    let response = make_delete_request(
+        app.router.clone(),
+        &format!("/thoughts/{}", thought_id),
+        Some(1),
+    )
+    .await;
     assert_eq!(response.status(), StatusCode::NO_CONTENT);
 }

thoughts-backend/tests/api/user.rs

@@ -1,19 +1,37 @@
-use axum::{http::StatusCode, Router};
+use axum::http::StatusCode;
 use http_body_util::BodyExt;
 use serde_json::Value;
 
 use utils::testing::{make_get_request, make_post_request};
 
-pub(super) async fn test_post_users(app: Router) {
-    let response = make_post_request(app, "/users", r#"{"username": "test"}"#.to_owned()).await;
+use crate::api::main::setup;
+
+#[tokio::test]
+async fn test_post_users() {
+    let app = setup().await;
+    let response = make_post_request(
+        app.router,
+        "/users",
+        r#"{"username": "test"}"#.to_owned(),
+        None,
+    )
+    .await;
     assert_eq!(response.status(), StatusCode::CREATED);
 
     let body = response.into_body().collect().await.unwrap().to_bytes();
     assert_eq!(&body[..], br#"{"id":1,"username":"test"}"#);
 }
 
-pub(super) async fn test_post_users_error(app: Router) {
-    let response = make_post_request(app, "/users", r#"{"username": "1"}"#.to_owned()).await;
+#[tokio::test]
+pub(super) async fn test_post_users_error() {
+    let app = setup().await;
+    let response = make_post_request(
+        app.router,
+        "/users",
+        r#"{"username": "1"}"#.to_owned(),
+        None,
+    )
+    .await;
     assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
 
     let body = response.into_body().collect().await.unwrap().to_bytes();
@@ -27,8 +45,18 @@ pub(super) async fn test_post_users_error(app: Router) {
     )
 }
 
-pub(super) async fn test_get_users(app: Router) {
-    let response = make_get_request(app, "/users").await;
+#[tokio::test]
+pub async fn test_get_users() {
+    let app = setup().await;
+    make_post_request(
+        app.router.clone(),
+        "/users",
+        r#"{"username": "test"}"#.to_owned(),
+        None,
+    )
+    .await;
+
+    let response = make_get_request(app.router, "/users", None).await;
     assert_eq!(response.status(), StatusCode::OK);
 
     let body = response.into_body().collect().await.unwrap().to_bytes();