feat: implement user follow/unfollow functionality and thought retrieval by user

- Added follow and unfollow endpoints for users.
- Implemented logic to retrieve thoughts by a specific user.
- Updated user error handling to include cases for already following and not following.
- Created persistence layer for follow relationships.
- Enhanced user and thought schemas to support new features.
- Added tests for follow/unfollow endpoints and thought retrieval.
- Updated frontend to display thoughts and allow posting new thoughts.

thoughts-backend/tests/api/feed.rs

@@ -0,0 +1,63 @@
+use super::main::{create_test_user, setup};
+use axum::http::StatusCode;
+use http_body_util::BodyExt;
+use serde_json::json;
+use utils::testing::{make_get_request, make_post_request};
+
+#[tokio::test]
+async fn test_feed_and_user_thoughts() {
+    let app = setup().await;
+    create_test_user(&app.db, "user1").await; // AuthUser is ID 1
+    create_test_user(&app.db, "user2").await;
+    create_test_user(&app.db, "user3").await;
+
+    // As user1, post a thought
+    let body = json!({ "content": "A thought from user1" }).to_string();
+    make_post_request(app.router.clone(), "/thoughts", body).await;
+
+    // As a different "user", create thoughts for user2 and user3 (we cheat here since auth is hardcoded)
+    app::persistence::thought::create_thought(
+        &app.db,
+        2,
+        models::params::thought::CreateThoughtParams {
+            content: "user2 was here".to_string(),
+        },
+    )
+    .await
+    .unwrap();
+    app::persistence::thought::create_thought(
+        &app.db,
+        3,
+        models::params::thought::CreateThoughtParams {
+            content: "user3 checking in".to_string(),
+        },
+    )
+    .await
+    .unwrap();
+
+    // 1. Get thoughts for user2 - should only see their thought
+    let response = make_get_request(app.router.clone(), "/users/user2/thoughts").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_eq!(v["thoughts"].as_array().unwrap().len(), 1);
+    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;
+    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;
+
+    // 4. user1's feed now has user2's thought
+    let response = make_get_request(app.router.clone(), "/feed").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_eq!(v["thoughts"].as_array().unwrap().len(), 1);
+    assert_eq!(v["thoughts"][0]["author_username"], "user2");
+}

thoughts-backend/tests/api/follow.rs

@@ -0,0 +1,33 @@
+use super::main::{create_test_user, setup};
+use axum::http::StatusCode;
+use utils::testing::{make_delete_request, make_post_request};
+
+#[tokio::test]
+async fn test_follow_endpoints() {
+    let app = setup().await;
+    create_test_user(&app.db, "user1").await; // AuthUser is ID 1
+    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;
+    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);
+
+    // 3. user1 tries to follow a non-existent user
+    let response =
+        make_post_request(app.router.clone(), "/users/nobody/follow", "".to_string()).await;
+    assert_eq!(response.status(), StatusCode::NOT_FOUND);
+
+    // 4. user1 unfollows user2
+    let response = make_delete_request(app.router.clone(), "/users/user2/follow").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;
+    assert_eq!(response.status(), StatusCode::NOT_FOUND);
+}

thoughts-backend/tests/api/main.rs

@@ -0,0 +1,29 @@
+use api::setup_router;
+use app::persistence::user::create_user;
+use axum::Router;
+use models::params::user::CreateUserParams;
+use sea_orm::DatabaseConnection;
+use utils::testing::setup_test_db;
+
+pub struct TestApp {
+    pub router: Router,
+    pub db: DatabaseConnection,
+}
+
+pub async fn setup() -> TestApp {
+    let db = setup_test_db("sqlite::memory:")
+        .await
+        .expect("Failed to set up test db");
+    let router = setup_router(db.clone());
+    TestApp { router, db }
+}
+
+// Helper to create users for tests
+pub async fn create_test_user(db: &DatabaseConnection, username: &str) {
+    let params = CreateUserParams {
+        username: username.to_string(),
+    };
+    create_user(db, params)
+        .await
+        .expect("Failed to create test user");
+}

thoughts-backend/tests/api/mod.rs

@@ -1,30 +1,5 @@
-use api::setup_router;
-use utils::testing::setup_test_db;
-
-mod root;
+mod feed;
+mod follow;
+mod main;
+mod thought;
 mod user;
-
-use root::*;
-use user::*;
-
-#[tokio::test]
-async fn root_main() {
-    let db = setup_test_db("sqlite::root?mode=memory&cache=shared")
-        .await
-        .expect("Set up db failed!");
-
-    let app = setup_router(db);
-    test_root(app).await;
-}
-
-#[tokio::test]
-async fn user_main() {
-    let db = setup_test_db("sqlite::user?mode=memory&cache=shared")
-        .await
-        .expect("Set up db failed!");
-
-    let app = setup_router(db);
-    test_post_users(app.clone()).await;
-    test_post_users_error(app.clone()).await;
-    test_get_users(app).await;
-}

thoughts-backend/tests/api/thought.rs

@@ -0,0 +1,36 @@
+use super::main::{create_test_user, setup};
+use axum::http::StatusCode;
+use http_body_util::BodyExt;
+use serde_json::json;
+use utils::testing::{make_delete_request, make_post_request};
+
+#[tokio::test]
+async fn test_thought_endpoints() {
+    let app = setup().await;
+    create_test_user(&app.db, "user1").await; // AuthUser is ID 1
+    create_test_user(&app.db, "user2").await; // Other user is ID 2
+
+    // 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;
+    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();
+    assert_eq!(v["content"], "My first thought!");
+    assert_eq!(v["author_username"], "user1");
+    let thought_id = v["id"].as_i64().unwrap();
+
+    // 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;
+    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;
+    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;
+    assert_eq!(response.status(), StatusCode::NO_CONTENT);
+}