(Almost) full test coverage

koucha/src/db/user.rs

@@ -39,6 +39,7 @@ impl User {
 
     user
   }
+
   pub async fn get_all(pool: &AdapterPool) -> Result<Vec<Self>> {
     let users: Result<Vec<Self>> = sqlx::query_as!(
       UnparsedUser,
@@ -88,93 +89,118 @@ impl User {
 #[cfg(test)]
 mod tests {
   use super::*;
-  use crate::{AdapterBuilder, Adapter};
+  use crate::{
+    db::Feed,
+    test_utils::{
+      USERNAME, USERNAME2, FEED_TITLE, FEED_TITLE2,
+      setup_adapter,
+    },
+  };
 
-  async fn setup_adapter() -> Adapter {
-    AdapterBuilder::new()
-      .database_url("sqlite::memory:")
-      .create().await.unwrap()
+  #[test]
+  fn parse() {
+    const UID: i64 = 1;
+    let unparsed_user = UnparsedUser {
+      id: UID,
+      name: USERNAME.to_string(),
+    };
+
+    let user = unparsed_user.parse().unwrap();
+    assert_eq!(user.id.0, UID);
+    assert_eq!(user.name, USERNAME);
+  }
+
+  #[tokio::test]
+  async fn get() {
+    let adapter = setup_adapter().await;
+		let pool = adapter.get_pool();
+    let new_user = User::create(pool, USERNAME).await.unwrap();
+
+    let fetched_user = User::get(pool, new_user.id).await.unwrap();
+    assert_eq!(fetched_user.name, USERNAME);
+    assert_eq!(fetched_user.id.0, 1);
   }
   
   #[tokio::test]
-  async fn get_user() {
+  async fn get_all() {
     let adapter = setup_adapter().await;
 		let pool = adapter.get_pool();
+    User::create(pool, USERNAME).await.unwrap();
+    User::create(pool, USERNAME2).await.unwrap();
 
-    let new_user = User::create(pool, "Alice").await.unwrap();
-
-    let fetched_user = User::get(pool, new_user.id).await.unwrap();
-    assert_eq!(fetched_user.name, "Alice");
-    assert!(fetched_user.id.0 > 0);
+    let users = User::get_all(pool).await.unwrap();
+    assert_eq!(users.len(), 2);
+    assert!(users.iter().any(|u| u.name == USERNAME));
+    assert!(users.iter().any(|u| u.name == USERNAME2));
   }
 
   #[tokio::test]
   async fn create_user() {
     let adapter = setup_adapter().await;
-		let pool = adapter.get_pool();
+    let pool = adapter.get_pool();
 
-    let user = User::create(pool, "Alice").await.unwrap();
+    let user = User::create(pool, USERNAME).await.unwrap();
 
-    assert_eq!(user.name, "Alice");
-    assert!(user.id.0 > 0);
+    assert_eq!(user.name, USERNAME);
+    assert_eq!(user.id.0, 1);
   }
-  
+
   #[tokio::test]
   async fn create_duplicate_user() {
     let adapter = setup_adapter().await;
-		let pool = adapter.get_pool();
+    let pool = adapter.get_pool();
 
-    let _user = User::create(pool, "Alice").await.unwrap();
-    let duplicate_user = User::create(pool, "Alice").await;
+    User::create(pool, USERNAME).await.unwrap();
+    let duplicate_user = User::create(pool, USERNAME).await;
 
     assert!(duplicate_user.is_err());
   }
-  
-  #[tokio::test]
-  async fn get_all_users() {
-    let adapter = setup_adapter().await;
-		let pool = adapter.get_pool();
-
-    User::create(pool, "Alice").await.unwrap();
-    User::create(pool, "Bob").await.unwrap();
-
-    let users = User::get_all(pool).await.unwrap();
-
-    assert_eq!(users.len(), 2);
-    assert!(users.iter().any(|u| u.name == "Alice"));
-    assert!(users.iter().any(|u| u.name == "Bob"));
-  }
 
   #[tokio::test]
   async fn update_name() {
+    const NEW_USERNAME: &str = "Alicia";
+    assert!(NEW_USERNAME != USERNAME);
     let adapter = setup_adapter().await;
-		let pool = adapter.get_pool();
+    let pool = adapter.get_pool();
 
-    let user = User::create(pool, "Alice").await.unwrap();
-    User::update_name(pool, user.id, "Alicia").await.unwrap();
+    let user = User::create(pool, USERNAME).await.unwrap();
+    User::update_name(pool, user.id, NEW_USERNAME).await.unwrap();
 
     let updated = User::get(pool, user.id).await.unwrap();
-    assert_eq!(updated.name, "Alicia");
+    assert_eq!(updated.name, NEW_USERNAME);
   }
-  
+
   #[tokio::test]
   async fn update_name_to_duplicate() {
     let adapter = setup_adapter().await;
-		let pool = adapter.get_pool();
+    let pool = adapter.get_pool();
 
-    let alice = User::create(pool, "Alice").await.unwrap();
-    let _sam = User::create(pool, "Sam").await.unwrap();
-    let status = User::update_name(pool, alice.id, "Sam").await;
+    let user1 = User::create(pool, USERNAME).await.unwrap();
+    User::create(pool, USERNAME2).await.unwrap();
+    let status = User::update_name(pool, user1.id, USERNAME2).await;
 
     assert!(status.is_err());
   }
 
+  #[tokio::test]
+  async fn get_feeds() {
+    let adapter = setup_adapter().await;
+    let pool = adapter.get_pool();
+    let user = User::create(pool, USERNAME).await.unwrap();
+    Feed::create(pool, user.id, FEED_TITLE).await.unwrap();
+    Feed::create(pool, user.id, FEED_TITLE2).await.unwrap();
+
+    let feeds = user.get_feeds(pool).await.unwrap();
+    assert_eq!(feeds.len(), 2);
+    assert!(feeds.iter().any(|f| f.title() == FEED_TITLE));
+    assert!(feeds.iter().any(|f| f.title() == FEED_TITLE2));
+  }
+
   #[tokio::test]
   async fn get_feeds_empty() {
     let adapter = setup_adapter().await;
-		let pool = adapter.get_pool();
-
-    let user = User::create(pool, "Alice").await.unwrap();
+    let pool = adapter.get_pool();
+    let user = User::create(pool, USERNAME).await.unwrap();
     let feeds = user.get_feeds(pool).await.unwrap();
 
     assert_eq!(feeds.len(), 0);