feat: Refactor user and thought models to use UUIDs instead of integers

- Updated user and thought models to utilize UUIDs for primary keys.
- Modified persistence functions to accommodate UUIDs for user and thought IDs.
- Implemented tag functionality with new Tag and ThoughtTag models.
- Added migration scripts to create new tables for tags and thought-tag relationships.
- Enhanced thought creation to parse hashtags and link them to thoughts.
- Updated tests to reflect changes in user and thought ID types.

thoughts-backend/tests/api/activitypub.rs

@@ -64,9 +64,9 @@ async fn test_user_actor_endpoint() {
 async fn test_user_inbox_follow() {
     let app = setup().await;
     // user1 will be followed
-    create_user_with_password(&app.db, "user1", "password123").await;
+    let user1 = create_user_with_password(&app.db, "user1", "password123").await;
     // user2 will be the follower
-    create_user_with_password(&app.db, "user2", "password123").await;
+    let user2 = create_user_with_password(&app.db, "user2", "password123").await;
 
     // Construct a follow activity from user2, targeting user1
     let follow_activity = json!({
@@ -90,16 +90,19 @@ async fn test_user_inbox_follow() {
     assert_eq!(response.status(), StatusCode::ACCEPTED);
 
     // Verify that user2 is now following user1 in the database
-    let followers = app::persistence::follow::get_followed_ids(&app.db, 2)
-        .await
-        .unwrap();
-    assert!(followers.contains(&1), "User2 should be following user1");
-
-    let following = app::persistence::follow::get_followed_ids(&app.db, 1)
+    let followers = app::persistence::follow::get_followed_ids(&app.db, user2.id)
         .await
         .unwrap();
     assert!(
-        !following.contains(&2),
+        followers.contains(&user1.id),
+        "User2 should be following user1"
+    );
+
+    let following = app::persistence::follow::get_followed_ids(&app.db, user1.id)
+        .await
+        .unwrap();
+    assert!(
+        !following.contains(&user2.id),
         "User1 should now be followed by user2"
     );
     assert!(following.is_empty(), "User1 should not be following anyone");

thoughts-backend/tests/api/auth.rs

@@ -20,7 +20,6 @@ async fn test_auth_flow() {
     let body = response.into_body().collect().await.unwrap().to_bytes();
     let v: Value = serde_json::from_slice(&body).unwrap();
     assert_eq!(v["username"], "testuser");
-    assert!(v["id"].is_number());
 
     let response = make_post_request(
         app.router.clone(),

thoughts-backend/tests/api/main.rs

@@ -1,8 +1,7 @@
 use api::setup_router;
-use app::persistence::user::create_user;
 use axum::Router;
 use http_body_util::BodyExt;
-use models::params::{auth::RegisterParams, user::CreateUserParams};
+use models::{domains::user, params::auth::RegisterParams};
 use sea_orm::DatabaseConnection;
 use serde_json::{json, Value};
 use utils::testing::{make_post_request, setup_test_db};
@@ -35,25 +34,18 @@ pub async fn setup() -> TestApp {
     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(),
-        password: "password".to_string(),
-    };
-    create_user(db, params)
-        .await
-        .expect("Failed to create test user");
-}
-
-pub async fn create_user_with_password(db: &DatabaseConnection, username: &str, password: &str) {
+pub async fn create_user_with_password(
+    db: &DatabaseConnection,
+    username: &str,
+    password: &str,
+) -> user::Model {
     let params = RegisterParams {
         username: username.to_string(),
         password: password.to_string(),
     };
     app::persistence::auth::register_user(db, params)
         .await
-        .expect("Failed to create test user with password");
+        .expect("Failed to create test user with password")
 }
 
 pub async fn login_user(router: Router, username: &str, password: &str) -> String {

thoughts-backend/tests/api/mod.rs

@@ -3,5 +3,6 @@ mod auth;
 mod feed;
 mod follow;
 mod main;
+mod tag;
 mod thought;
 mod user;

thoughts-backend/tests/api/tag.rs

@@ -0,0 +1,51 @@
+use crate::api::main::{create_user_with_password, login_user, setup};
+use axum::http::StatusCode;
+use http_body_util::BodyExt;
+use serde_json::{json, Value};
+use utils::testing::{make_get_request, make_jwt_request};
+
+#[tokio::test]
+async fn test_hashtag_flow() {
+    let app = setup().await;
+    let user = create_user_with_password(&app.db, "taguser", "password123").await;
+    let token = login_user(app.router.clone(), "taguser", "password123").await;
+
+    // 1. Post a thought with hashtags
+    let body = json!({ "content": "Hello #world this is a post about #RustLang" }).to_string();
+    let response =
+        make_jwt_request(app.router.clone(), "/thoughts", "POST", Some(body), &token).await;
+    assert_eq!(response.status(), StatusCode::CREATED);
+    let body_bytes = response.into_body().collect().await.unwrap().to_bytes();
+    let thought_json: Value = serde_json::from_slice(&body_bytes).unwrap();
+    let thought_id = thought_json["id"].as_str().unwrap();
+
+    // 2. Post another thought
+    let body2 = json!({ "content": "Another post about the #rustlang ecosystem" }).to_string();
+    make_jwt_request(app.router.clone(), "/thoughts", "POST", Some(body2), &token).await;
+
+    // 3. Fetch thoughts by tag "rustlang"
+    let response = make_get_request(app.router.clone(), "/tags/rustlang", Some(user.id)).await;
+    println!("Response: {:?}", response);
+    assert_eq!(response.status(), StatusCode::OK);
+    let body_bytes = response.into_body().collect().await.unwrap().to_bytes();
+    let v: Value = serde_json::from_slice(&body_bytes).unwrap();
+
+    let thoughts = v["thoughts"].as_array().unwrap();
+    assert_eq!(thoughts.len(), 2);
+    // Note: The most recent post appears first
+    assert_eq!(
+        thoughts[0]["content"],
+        "Another post about the #rustlang ecosystem"
+    );
+    assert_eq!(thoughts[1]["id"], thought_id);
+
+    // 4. Fetch thoughts by tag "world"
+    let response = make_get_request(app.router.clone(), "/tags/world", Some(user.id)).await;
+    assert_eq!(response.status(), StatusCode::OK);
+    let body_bytes = response.into_body().collect().await.unwrap().to_bytes();
+    let v: Value = serde_json::from_slice(&body_bytes).unwrap();
+
+    let thoughts = v["thoughts"].as_array().unwrap();
+    assert_eq!(thoughts.len(), 1);
+    assert_eq!(thoughts[0]["id"], thought_id);
+}

thoughts-backend/tests/api/thought.rs

@@ -1,40 +1,47 @@
-use super::main::{create_test_user, setup};
+use crate::api::main::create_user_with_password;
+
+use super::main::setup;
 use axum::http::StatusCode;
 use http_body_util::BodyExt;
+use sea_orm::prelude::Uuid;
 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
+    let user1 = create_user_with_password(&app.db, "user1", "password123").await; // AuthUser is ID 1
+    let _user2 = create_user_with_password(&app.db, "user2", "password123").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, Some(1)).await;
+    let response = make_post_request(app.router.clone(), "/thoughts", body, Some(user1.id)).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();
+    let thought_id = v["id"].as_str().unwrap().to_string();
 
     // 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, Some(1)).await;
+    let response = make_post_request(app.router.clone(), "/thoughts", body, Some(user1.id)).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"), Some(1)).await;
+    let response = make_delete_request(
+        app.router.clone(),
+        &format!("/thoughts/{}", Uuid::new_v4()),
+        Some(user1.id),
+    )
+    .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),
-        Some(1),
+        Some(user1.id),
     )
     .await;
     assert_eq!(response.status(), StatusCode::NO_CONTENT);

thoughts-backend/tests/api/user.rs

@@ -1,10 +1,12 @@
 use axum::http::StatusCode;
 use http_body_util::BodyExt;
+use models::domains::top_friends;
+use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
 use serde_json::{json, Value};
 
 use utils::testing::{make_get_request, make_jwt_request, make_post_request};
 
-use crate::api::main::{login_user, setup};
+use crate::api::main::{create_user_with_password, login_user, setup};
 
 #[tokio::test]
 async fn test_post_users() {
@@ -18,7 +20,6 @@ async fn test_post_users() {
     let body = response.into_body().collect().await.unwrap().to_bytes();
     let v: Value = serde_json::from_slice(&body).unwrap();
 
-    assert_eq!(v["id"], 1);
     assert_eq!(v["username"], "test");
     assert!(v["display_name"].is_null());
 }
@@ -54,7 +55,6 @@ pub async fn test_get_users() {
     assert!(v["users"].is_array());
     let users_array = v["users"].as_array().unwrap();
     assert_eq!(users_array.len(), 1);
-    assert_eq!(users_array[0]["id"], 1);
     assert_eq!(users_array[0]["username"], "test");
 }
 
@@ -113,3 +113,73 @@ async fn test_me_endpoints() {
     assert_eq!(v_verify["display_name"], "Me User");
     assert_eq!(v_verify["bio"], "This is my updated bio.");
 }
+
+#[tokio::test]
+async fn test_update_me_top_friends() {
+    let app = setup().await;
+
+    // 1. Create users for the test
+    let user_me = create_user_with_password(&app.db, "me_user", "password123").await;
+    let friend1 = create_user_with_password(&app.db, "friend1", "password123").await;
+    let friend2 = create_user_with_password(&app.db, "friend2", "password123").await;
+    let _friend3 = create_user_with_password(&app.db, "friend3", "password123").await;
+
+    // 2. Log in as "me_user"
+    let token = login_user(app.router.clone(), "me_user", "password123").await;
+
+    // 3. Update profile to set top friends
+    let update_body = json!({
+        "top_friends": ["friend1", "friend2"]
+    })
+    .to_string();
+
+    let response = make_jwt_request(
+        app.router.clone(),
+        "/users/me",
+        "PUT",
+        Some(update_body),
+        &token,
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::OK);
+
+    // 4. Verify the database state directly
+    let top_friends_list = top_friends::Entity::find()
+        .filter(top_friends::Column::UserId.eq(user_me.id))
+        .all(&app.db)
+        .await
+        .unwrap();
+
+    assert_eq!(top_friends_list.len(), 2);
+    assert_eq!(top_friends_list[0].friend_id, friend1.id);
+    assert_eq!(top_friends_list[0].position, 1);
+    assert_eq!(top_friends_list[1].friend_id, friend2.id);
+    assert_eq!(top_friends_list[1].position, 2);
+
+    // 5. Update again with a different list to test replacement
+    let update_body_2 = json!({
+        "top_friends": ["friend2"]
+    })
+    .to_string();
+
+    let response = make_jwt_request(
+        app.router.clone(),
+        "/users/me",
+        "PUT",
+        Some(update_body_2),
+        &token,
+    )
+    .await;
+    assert_eq!(response.status(), StatusCode::OK);
+
+    // 6. Verify the new state
+    let top_friends_list_2 = top_friends::Entity::find()
+        .filter(top_friends::Column::UserId.eq(user_me.id))
+        .all(&app.db)
+        .await
+        .unwrap();
+
+    assert_eq!(top_friends_list_2.len(), 1);
+    assert_eq!(top_friends_list_2[0].friend_id, friend2.id);
+    assert_eq!(top_friends_list_2[0].position, 1);
+}

thoughts-backend/tests/app/persistence/user.rs

@@ -14,6 +14,5 @@ pub(super) async fn test_user(db: &DatabaseConnection) {
         .try_into_model() // Convert ActiveModel to Model for easier checks
         .unwrap();
 
-    assert_eq!(user_model.id, 1);
     assert_eq!(user_model.username, "test");
 }