Move to DB module for visibility; separate db and client code

koucha/src/db/user.rs

@@ -0,0 +1,182 @@
+use crate::{
+  Result,
+  AdapterPool,
+  db::{
+    UserId,
+    Feed,
+    feed::UnparsedFeed,
+  },
+};
+
+pub struct UnparsedUser {
+  pub id: i64,
+  pub name: String,
+}
+impl UnparsedUser {
+  pub fn parse(self) -> Result<User> {
+    Ok(User {
+      id: UserId(self.id),
+      name: self.name
+    })
+  }
+}
+
+pub struct User {
+  id: UserId,
+  name: String,
+}
+
+impl User {
+  pub fn id(&self) -> UserId { self.id }
+  pub fn name(&self) -> &str { &self.name }
+
+  pub async fn get(pool: &AdapterPool, id: UserId) -> Result<Self> {
+    let user = sqlx::query_as!(
+      UnparsedUser,
+      "SELECT id, name FROM users WHERE id = ?",
+      id.0
+    ).fetch_one(&pool.0).await?.parse();
+
+    user
+  }
+  pub async fn get_all(pool: &AdapterPool) -> Result<Vec<Self>> {
+    let users: Result<Vec<Self>> = sqlx::query_as!(
+      UnparsedUser,
+      "SELECT id, name FROM users"
+    ).fetch_all(&pool.0).await?.into_iter().map(UnparsedUser::parse).collect();
+
+    users
+  }
+
+  pub async fn create(pool: &AdapterPool, name: &str) -> Result<Self> {
+    let result = sqlx::query!(
+      "INSERT INTO users (name)
+       VALUES (?)
+       RETURNING id, name",
+      name
+    ).fetch_one(&pool.0).await?;
+
+    Ok(Self {
+      id: UserId(result.id),
+      name: result.name,
+    })
+  }
+
+  pub async fn update_name(
+      pool: &AdapterPool, id: UserId, new_name: &str
+  ) -> Result<()> {
+    sqlx::query!(
+      "UPDATE users SET name = ? WHERE id = ?",
+      new_name, id.0
+    ).execute(&pool.0).await?;
+
+    Ok(())
+  }
+
+  pub async fn get_feeds(&self, pool: &AdapterPool) -> Result<Vec<Feed>> {
+    let feeds: Result<Vec<Feed>> = sqlx::query_as!(
+        UnparsedFeed,
+        "SELECT id, title FROM feeds WHERE user_id = ?",
+        self.id.0
+      ).fetch_all(&pool.0).await?.into_iter()
+        .map(UnparsedFeed::parse).collect();
+
+    feeds
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+  use crate::{AdapterBuilder, Adapter};
+
+  async fn setup_adapter() -> Adapter {
+    AdapterBuilder::new()
+      .database_url("sqlite::memory:")
+      .create().await.unwrap()
+  }
+  
+  #[tokio::test]
+  async fn get_user() {
+    let adapter = setup_adapter().await;
+		let pool = adapter.get_pool();
+
+    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);
+  }
+
+  #[tokio::test]
+  async fn create_user() {
+    let adapter = setup_adapter().await;
+		let pool = adapter.get_pool();
+
+    let user = User::create(pool, "Alice").await.unwrap();
+
+    assert_eq!(user.name, "Alice");
+    assert!(user.id.0 > 0);
+  }
+  
+  #[tokio::test]
+  async fn create_duplicate_user() {
+    let adapter = setup_adapter().await;
+		let pool = adapter.get_pool();
+
+    let _user = User::create(pool, "Alice").await.unwrap();
+    let duplicate_user = User::create(pool, "Alice").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() {
+    let adapter = setup_adapter().await;
+		let pool = adapter.get_pool();
+
+    let user = User::create(pool, "Alice").await.unwrap();
+    User::update_name(pool, user.id, "Alicia").await.unwrap();
+
+    let updated = User::get(pool, user.id).await.unwrap();
+    assert_eq!(updated.name, "Alicia");
+  }
+  
+  #[tokio::test]
+  async fn update_name_to_duplicate() {
+    let adapter = setup_adapter().await;
+		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;
+
+    assert!(status.is_err());
+  }
+
+  #[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 feeds = user.get_feeds(pool).await.unwrap();
+
+    assert_eq!(feeds.len(), 0);
+  }
+}