Julia/Koucha
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
Julia Lange 2026-01-22 13:49:49 -08:00
parent f5fc83a471
commit 3748606e21
Signed by: Julia
SSH key fingerprint: SHA256:5DJcfxa5/fKCYn57dcabJa2vN2e6eT0pBerYi5SUbto
9 changed files with 340 additions and 399 deletions
Download patch file Download diff file Expand all files Collapse all files

183
koucha/src/user.rs
View file

@ -1,183 +0,0 @@
use crate::{
Result,
AdapterPool,
Feed,
feed::UnparsedFeed,
};
#[derive(Copy, Clone)]
pub struct UserId(i64);
impl From<UserId> for i64 { fn from(id: UserId) -> Self { id.0 } }
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);
}
}