82 lines
3.2 KiB
Rust
82 lines
3.2 KiB
Rust
use async_trait::async_trait;
|
|
use sqlx::PgPool;
|
|
use domain::{errors::DomainError, models::social::Block, ports::BlockRepository, value_objects::UserId};
|
|
|
|
pub struct PgBlockRepository { pool: PgPool }
|
|
impl PgBlockRepository { pub fn new(pool: PgPool) -> Self { Self { pool } } }
|
|
|
|
#[async_trait]
|
|
impl BlockRepository for PgBlockRepository {
|
|
async fn save(&self, b: &Block) -> Result<(), DomainError> {
|
|
sqlx::query(
|
|
"INSERT INTO blocks(blocker_id,blocked_id,created_at) VALUES($1,$2,$3) ON CONFLICT DO NOTHING"
|
|
)
|
|
.bind(b.blocker_id.as_uuid())
|
|
.bind(b.blocked_id.as_uuid())
|
|
.bind(b.created_at)
|
|
.execute(&self.pool)
|
|
.await
|
|
.map_err(|e| DomainError::Internal(e.to_string()))
|
|
.map(|_| ())
|
|
}
|
|
|
|
async fn delete(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<(), DomainError> {
|
|
sqlx::query("DELETE FROM blocks WHERE blocker_id=$1 AND blocked_id=$2")
|
|
.bind(blocker_id.as_uuid())
|
|
.bind(blocked_id.as_uuid())
|
|
.execute(&self.pool)
|
|
.await
|
|
.map_err(|e| DomainError::Internal(e.to_string()))
|
|
.map(|_| ())
|
|
}
|
|
|
|
async fn exists(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<bool, DomainError> {
|
|
let count: i64 = sqlx::query_scalar(
|
|
"SELECT COUNT(*) FROM blocks WHERE blocker_id=$1 AND blocked_id=$2"
|
|
)
|
|
.bind(blocker_id.as_uuid())
|
|
.bind(blocked_id.as_uuid())
|
|
.fetch_one(&self.pool)
|
|
.await
|
|
.map_err(|e| DomainError::Internal(e.to_string()))?;
|
|
Ok(count > 0)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use chrono::Utc;
|
|
use domain::{models::user::User, value_objects::*};
|
|
use crate::user::PgUserRepository;
|
|
use domain::ports::UserRepository;
|
|
|
|
async fn seed_user(pool: &sqlx::PgPool, username: &str, email: &str) -> User {
|
|
let repo = PgUserRepository::new(pool.clone());
|
|
let u = User::new_local(UserId::new(), Username::new(username).unwrap(), Email::new(email).unwrap(), PasswordHash("h".into()));
|
|
repo.save(&u).await.unwrap(); u
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn block_exists(pool: sqlx::PgPool) {
|
|
let alice = seed_user(&pool, "alice", "alice@ex.com").await;
|
|
let bob = seed_user(&pool, "bob", "bob@ex.com").await;
|
|
let repo = PgBlockRepository::new(pool);
|
|
let block = Block { blocker_id: alice.id.clone(), blocked_id: bob.id.clone(), created_at: Utc::now() };
|
|
repo.save(&block).await.unwrap();
|
|
assert!(repo.exists(&alice.id, &bob.id).await.unwrap());
|
|
assert!(!repo.exists(&bob.id, &alice.id).await.unwrap());
|
|
}
|
|
|
|
#[sqlx::test(migrations = "./migrations")]
|
|
async fn unblock(pool: sqlx::PgPool) {
|
|
let alice = seed_user(&pool, "alice", "alice@ex.com").await;
|
|
let bob = seed_user(&pool, "bob", "bob@ex.com").await;
|
|
let repo = PgBlockRepository::new(pool);
|
|
let block = Block { blocker_id: alice.id.clone(), blocked_id: bob.id.clone(), created_at: Utc::now() };
|
|
repo.save(&block).await.unwrap();
|
|
repo.delete(&alice.id, &bob.id).await.unwrap();
|
|
assert!(!repo.exists(&alice.id, &bob.id).await.unwrap());
|
|
}
|
|
}
|