959 lines
26 KiB
Rust
959 lines
26 KiB
Rust
use crate::{
|
|
errors::DomainError,
|
|
events::DomainEvent,
|
|
models::{
|
|
api_key::ApiKey,
|
|
feed::{FeedEntry, PageParams, Paginated, UserSummary},
|
|
notification::Notification,
|
|
remote_actor::RemoteActor,
|
|
social::{Block, Boost, Follow, FollowState, Like},
|
|
tag::Tag,
|
|
thought::Thought,
|
|
top_friend::TopFriend,
|
|
user::User,
|
|
},
|
|
ports::*,
|
|
value_objects::{
|
|
ApiKeyId, Content, Email, NotificationId, PasswordHash, ThoughtId, UserId, Username,
|
|
},
|
|
};
|
|
use async_trait::async_trait;
|
|
use chrono::Utc;
|
|
use std::sync::{Arc, Mutex};
|
|
use url;
|
|
|
|
#[derive(Default, Clone)]
|
|
pub struct TestStore {
|
|
pub users: Arc<Mutex<Vec<User>>>,
|
|
pub thoughts: Arc<Mutex<Vec<Thought>>>,
|
|
pub likes: Arc<Mutex<Vec<Like>>>,
|
|
pub boosts: Arc<Mutex<Vec<Boost>>>,
|
|
pub follows: Arc<Mutex<Vec<Follow>>>,
|
|
pub blocks: Arc<Mutex<Vec<Block>>>,
|
|
pub tags: Arc<Mutex<Vec<Tag>>>,
|
|
pub api_keys: Arc<Mutex<Vec<ApiKey>>>,
|
|
pub top_friends: Arc<Mutex<Vec<TopFriend>>>,
|
|
pub notifications: Arc<Mutex<Vec<Notification>>>,
|
|
pub events: Arc<Mutex<Vec<DomainEvent>>>,
|
|
}
|
|
|
|
#[async_trait]
|
|
impl UserRepository for TestStore {
|
|
async fn find_by_id(&self, id: &UserId) -> Result<Option<User>, DomainError> {
|
|
Ok(self
|
|
.users
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|u| &u.id == id)
|
|
.cloned())
|
|
}
|
|
async fn find_by_username(&self, username: &Username) -> Result<Option<User>, DomainError> {
|
|
Ok(self
|
|
.users
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|u| u.username.as_str() == username.as_str())
|
|
.cloned())
|
|
}
|
|
async fn find_by_email(&self, email: &Email) -> Result<Option<User>, DomainError> {
|
|
Ok(self
|
|
.users
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|u| u.email.as_str() == email.as_str())
|
|
.cloned())
|
|
}
|
|
async fn save(&self, user: &User) -> Result<(), DomainError> {
|
|
let mut g = self.users.lock().unwrap();
|
|
g.retain(|u| u.id != user.id);
|
|
g.push(user.clone());
|
|
Ok(())
|
|
}
|
|
async fn update_profile(
|
|
&self,
|
|
user_id: &UserId,
|
|
display_name: Option<String>,
|
|
bio: Option<String>,
|
|
avatar_url: Option<String>,
|
|
header_url: Option<String>,
|
|
custom_css: Option<String>,
|
|
) -> Result<(), DomainError> {
|
|
if let Some(u) = self
|
|
.users
|
|
.lock()
|
|
.unwrap()
|
|
.iter_mut()
|
|
.find(|u| &u.id == user_id)
|
|
{
|
|
u.display_name = display_name;
|
|
u.bio = bio;
|
|
u.avatar_url = avatar_url;
|
|
u.header_url = header_url;
|
|
u.custom_css = custom_css;
|
|
}
|
|
Ok(())
|
|
}
|
|
async fn list_with_stats(&self) -> Result<Vec<UserSummary>, DomainError> {
|
|
Ok(vec![])
|
|
}
|
|
async fn count(&self) -> Result<i64, DomainError> {
|
|
Ok(self
|
|
.users
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.filter(|u| u.local)
|
|
.count() as i64)
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl ThoughtRepository for TestStore {
|
|
async fn save(&self, t: &Thought) -> Result<(), DomainError> {
|
|
let mut g = self.thoughts.lock().unwrap();
|
|
g.retain(|x| x.id != t.id);
|
|
g.push(t.clone());
|
|
Ok(())
|
|
}
|
|
async fn find_by_id(&self, id: &ThoughtId) -> Result<Option<Thought>, DomainError> {
|
|
Ok(self
|
|
.thoughts
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|t| &t.id == id)
|
|
.cloned())
|
|
}
|
|
async fn delete(&self, id: &ThoughtId, user_id: &UserId) -> Result<(), DomainError> {
|
|
let mut g = self.thoughts.lock().unwrap();
|
|
let before = g.len();
|
|
g.retain(|t| !(&t.id == id && &t.user_id == user_id));
|
|
if g.len() == before {
|
|
return Err(DomainError::NotFound);
|
|
}
|
|
Ok(())
|
|
}
|
|
async fn update_content(&self, id: &ThoughtId, content: &Content) -> Result<(), DomainError> {
|
|
if let Some(t) = self
|
|
.thoughts
|
|
.lock()
|
|
.unwrap()
|
|
.iter_mut()
|
|
.find(|t| &t.id == id)
|
|
{
|
|
t.content = content.clone();
|
|
t.updated_at = Some(Utc::now());
|
|
}
|
|
Ok(())
|
|
}
|
|
async fn get_thread(&self, id: &ThoughtId) -> Result<Vec<Thought>, DomainError> {
|
|
Ok(self
|
|
.thoughts
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.filter(|t| t.in_reply_to_id.as_ref() == Some(id) || &t.id == id)
|
|
.cloned()
|
|
.collect())
|
|
}
|
|
async fn list_by_user(
|
|
&self,
|
|
_user_id: &UserId,
|
|
_page: &PageParams,
|
|
) -> Result<Paginated<Thought>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl LikeRepository for TestStore {
|
|
async fn save(&self, like: &Like) -> Result<(), DomainError> {
|
|
let mut g = self.likes.lock().unwrap();
|
|
if g.iter()
|
|
.any(|l| l.user_id == like.user_id && l.thought_id == like.thought_id)
|
|
{
|
|
return Err(DomainError::Conflict("already liked".into()));
|
|
}
|
|
g.push(like.clone());
|
|
Ok(())
|
|
}
|
|
async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
|
|
let mut g = self.likes.lock().unwrap();
|
|
let before = g.len();
|
|
g.retain(|l| !(&l.user_id == user_id && &l.thought_id == thought_id));
|
|
if g.len() == before {
|
|
return Err(DomainError::NotFound);
|
|
}
|
|
Ok(())
|
|
}
|
|
async fn find(
|
|
&self,
|
|
user_id: &UserId,
|
|
thought_id: &ThoughtId,
|
|
) -> Result<Option<Like>, DomainError> {
|
|
Ok(self
|
|
.likes
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|l| &l.user_id == user_id && &l.thought_id == thought_id)
|
|
.cloned())
|
|
}
|
|
async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError> {
|
|
Ok(self
|
|
.likes
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.filter(|l| &l.thought_id == thought_id)
|
|
.count() as i64)
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl BoostRepository for TestStore {
|
|
async fn save(&self, boost: &Boost) -> Result<(), DomainError> {
|
|
let mut g = self.boosts.lock().unwrap();
|
|
if g.iter()
|
|
.any(|b| b.user_id == boost.user_id && b.thought_id == boost.thought_id)
|
|
{
|
|
return Err(DomainError::Conflict("already boosted".into()));
|
|
}
|
|
g.push(boost.clone());
|
|
Ok(())
|
|
}
|
|
async fn delete(&self, user_id: &UserId, thought_id: &ThoughtId) -> Result<(), DomainError> {
|
|
let mut g = self.boosts.lock().unwrap();
|
|
let before = g.len();
|
|
g.retain(|b| !(&b.user_id == user_id && &b.thought_id == thought_id));
|
|
if g.len() == before {
|
|
return Err(DomainError::NotFound);
|
|
}
|
|
Ok(())
|
|
}
|
|
async fn find(
|
|
&self,
|
|
user_id: &UserId,
|
|
thought_id: &ThoughtId,
|
|
) -> Result<Option<Boost>, DomainError> {
|
|
Ok(self
|
|
.boosts
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|b| &b.user_id == user_id && &b.thought_id == thought_id)
|
|
.cloned())
|
|
}
|
|
async fn count_for_thought(&self, thought_id: &ThoughtId) -> Result<i64, DomainError> {
|
|
Ok(self
|
|
.boosts
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.filter(|b| &b.thought_id == thought_id)
|
|
.count() as i64)
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl FollowRepository for TestStore {
|
|
async fn save(&self, follow: &Follow) -> Result<(), DomainError> {
|
|
let mut g = self.follows.lock().unwrap();
|
|
g.retain(|f| {
|
|
!(f.follower_id == follow.follower_id && f.following_id == follow.following_id)
|
|
});
|
|
g.push(follow.clone());
|
|
Ok(())
|
|
}
|
|
async fn delete(&self, follower_id: &UserId, following_id: &UserId) -> Result<(), DomainError> {
|
|
let mut g = self.follows.lock().unwrap();
|
|
let before = g.len();
|
|
g.retain(|f| !(&f.follower_id == follower_id && &f.following_id == following_id));
|
|
if g.len() == before {
|
|
return Err(DomainError::NotFound);
|
|
}
|
|
Ok(())
|
|
}
|
|
async fn find(
|
|
&self,
|
|
follower_id: &UserId,
|
|
following_id: &UserId,
|
|
) -> Result<Option<Follow>, DomainError> {
|
|
Ok(self
|
|
.follows
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|f| &f.follower_id == follower_id && &f.following_id == following_id)
|
|
.cloned())
|
|
}
|
|
async fn update_state(
|
|
&self,
|
|
follower_id: &UserId,
|
|
following_id: &UserId,
|
|
state: &FollowState,
|
|
) -> Result<(), DomainError> {
|
|
if let Some(f) = self
|
|
.follows
|
|
.lock()
|
|
.unwrap()
|
|
.iter_mut()
|
|
.find(|f| &f.follower_id == follower_id && &f.following_id == following_id)
|
|
{
|
|
f.state = state.clone();
|
|
}
|
|
Ok(())
|
|
}
|
|
async fn list_followers(
|
|
&self,
|
|
_user_id: &UserId,
|
|
_p: &PageParams,
|
|
) -> Result<Paginated<User>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
async fn list_following(
|
|
&self,
|
|
_user_id: &UserId,
|
|
_p: &PageParams,
|
|
) -> Result<Paginated<User>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
async fn get_accepted_following_ids(
|
|
&self,
|
|
user_id: &UserId,
|
|
) -> Result<Vec<UserId>, DomainError> {
|
|
Ok(self
|
|
.follows
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.filter(|f| &f.follower_id == user_id && f.state == FollowState::Accepted)
|
|
.map(|f| f.following_id.clone())
|
|
.collect())
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl BlockRepository for TestStore {
|
|
async fn save(&self, block: &Block) -> Result<(), DomainError> {
|
|
self.blocks.lock().unwrap().push(block.clone());
|
|
Ok(())
|
|
}
|
|
async fn delete(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<(), DomainError> {
|
|
self.blocks
|
|
.lock()
|
|
.unwrap()
|
|
.retain(|b| !(&b.blocker_id == blocker_id && &b.blocked_id == blocked_id));
|
|
Ok(())
|
|
}
|
|
async fn exists(&self, blocker_id: &UserId, blocked_id: &UserId) -> Result<bool, DomainError> {
|
|
Ok(self
|
|
.blocks
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.any(|b| &b.blocker_id == blocker_id && &b.blocked_id == blocked_id))
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl TagRepository for TestStore {
|
|
async fn find_or_create(&self, name: &str) -> Result<Tag, DomainError> {
|
|
let mut g = self.tags.lock().unwrap();
|
|
if let Some(t) = g.iter().find(|t| t.name == name) {
|
|
return Ok(t.clone());
|
|
}
|
|
let tag = Tag {
|
|
id: g.len() as i32 + 1,
|
|
name: name.to_string(),
|
|
};
|
|
g.push(tag.clone());
|
|
Ok(tag)
|
|
}
|
|
async fn attach_to_thought(&self, _tid: &ThoughtId, _tag_id: i32) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
async fn detach_from_thought(&self, _tid: &ThoughtId) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
async fn list_for_thought(&self, _tid: &ThoughtId) -> Result<Vec<Tag>, DomainError> {
|
|
Ok(vec![])
|
|
}
|
|
async fn list_thoughts_by_tag(
|
|
&self,
|
|
_name: &str,
|
|
_p: &PageParams,
|
|
) -> Result<Paginated<Thought>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
async fn popular_tags(&self, _limit: usize) -> Result<Vec<(String, i64)>, DomainError> {
|
|
Ok(vec![])
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl ApiKeyRepository for TestStore {
|
|
async fn save(&self, key: &ApiKey) -> Result<(), DomainError> {
|
|
self.api_keys.lock().unwrap().push(key.clone());
|
|
Ok(())
|
|
}
|
|
async fn find_by_hash(&self, hash: &str) -> Result<Option<ApiKey>, DomainError> {
|
|
Ok(self
|
|
.api_keys
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|k| k.key_hash == hash)
|
|
.cloned())
|
|
}
|
|
async fn list_for_user(&self, uid: &UserId) -> Result<Vec<ApiKey>, DomainError> {
|
|
Ok(self
|
|
.api_keys
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.filter(|k| &k.user_id == uid)
|
|
.cloned()
|
|
.collect())
|
|
}
|
|
async fn delete(&self, id: &ApiKeyId, uid: &UserId) -> Result<(), DomainError> {
|
|
self.api_keys
|
|
.lock()
|
|
.unwrap()
|
|
.retain(|k| !(&k.id == id && &k.user_id == uid));
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl TopFriendRepository for TestStore {
|
|
async fn set_top_friends(
|
|
&self,
|
|
user_id: &UserId,
|
|
friends: Vec<(UserId, i16)>,
|
|
) -> Result<(), DomainError> {
|
|
let mut g = self.top_friends.lock().unwrap();
|
|
g.retain(|tf| &tf.user_id != user_id);
|
|
for (fid, pos) in friends {
|
|
g.push(TopFriend {
|
|
user_id: user_id.clone(),
|
|
friend_id: fid,
|
|
position: pos,
|
|
});
|
|
}
|
|
Ok(())
|
|
}
|
|
async fn list_for_user(&self, _uid: &UserId) -> Result<Vec<(TopFriend, User)>, DomainError> {
|
|
Ok(vec![])
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl NotificationRepository for TestStore {
|
|
async fn save(&self, n: &Notification) -> Result<(), DomainError> {
|
|
self.notifications.lock().unwrap().push(n.clone());
|
|
Ok(())
|
|
}
|
|
async fn list_for_user(
|
|
&self,
|
|
uid: &UserId,
|
|
_p: &PageParams,
|
|
) -> Result<Paginated<Notification>, DomainError> {
|
|
let items: Vec<_> = self
|
|
.notifications
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.filter(|n| &n.user_id == uid)
|
|
.cloned()
|
|
.collect();
|
|
let total = items.len() as i64;
|
|
Ok(Paginated {
|
|
items,
|
|
total,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
async fn mark_read(&self, id: &NotificationId, _uid: &UserId) -> Result<(), DomainError> {
|
|
if let Some(n) = self
|
|
.notifications
|
|
.lock()
|
|
.unwrap()
|
|
.iter_mut()
|
|
.find(|n| &n.id == id)
|
|
{
|
|
n.read = true;
|
|
}
|
|
Ok(())
|
|
}
|
|
async fn mark_all_read(&self, uid: &UserId) -> Result<(), DomainError> {
|
|
for n in self
|
|
.notifications
|
|
.lock()
|
|
.unwrap()
|
|
.iter_mut()
|
|
.filter(|n| &n.user_id == uid)
|
|
{
|
|
n.read = true;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl RemoteActorRepository for TestStore {
|
|
async fn upsert(&self, _a: &RemoteActor) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
async fn find_by_url(&self, _url: &str) -> Result<Option<RemoteActor>, DomainError> {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl FederationActionPort for TestStore {
|
|
async fn lookup_actor(&self, _handle: &str) -> Result<RemoteActor, DomainError> {
|
|
Err(DomainError::NotFound)
|
|
}
|
|
|
|
async fn follow_remote(
|
|
&self,
|
|
_local_user_id: &UserId,
|
|
_handle: &str,
|
|
) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn actor_json(&self, _user_id: &UserId) -> Result<String, DomainError> {
|
|
Err(DomainError::NotFound)
|
|
}
|
|
|
|
async fn followers_collection_json(
|
|
&self,
|
|
_user_id: &UserId,
|
|
_page: Option<u32>,
|
|
) -> Result<String, DomainError> {
|
|
Err(DomainError::NotFound)
|
|
}
|
|
|
|
async fn following_collection_json(
|
|
&self,
|
|
_user_id: &UserId,
|
|
_page: Option<u32>,
|
|
) -> Result<String, DomainError> {
|
|
Err(DomainError::NotFound)
|
|
}
|
|
|
|
async fn fetch_outbox_page(
|
|
&self,
|
|
_outbox_url: &str,
|
|
_page: u32,
|
|
) -> Result<Vec<crate::models::remote_note::RemoteNote>, DomainError> {
|
|
Ok(vec![])
|
|
}
|
|
|
|
async fn fetch_actor_urls_from_collection(
|
|
&self,
|
|
_collection_url: &str,
|
|
) -> Result<Vec<String>, DomainError> {
|
|
Ok(vec![])
|
|
}
|
|
|
|
async fn resolve_actor_profiles(
|
|
&self,
|
|
_urls: Vec<String>,
|
|
) -> Vec<crate::models::actor_connection_summary::ActorConnectionSummary> {
|
|
vec![]
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl RemoteActorConnectionRepository for TestStore {
|
|
async fn upsert_connections(
|
|
&self,
|
|
_actor_url: &str,
|
|
_connection_type: &str,
|
|
_page: u32,
|
|
_actors: &[crate::models::actor_connection_summary::ActorConnectionSummary],
|
|
) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
|
|
async fn list_connections(
|
|
&self,
|
|
_actor_url: &str,
|
|
_connection_type: &str,
|
|
_page: u32,
|
|
) -> Result<Vec<crate::models::actor_connection_summary::ActorConnectionSummary>, DomainError>
|
|
{
|
|
Ok(vec![])
|
|
}
|
|
|
|
async fn connection_page_age(
|
|
&self,
|
|
_actor_url: &str,
|
|
_connection_type: &str,
|
|
_page: u32,
|
|
) -> Result<Option<chrono::DateTime<chrono::Utc>>, DomainError> {
|
|
Ok(None)
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl FeedRepository for TestStore {
|
|
async fn home_feed(
|
|
&self,
|
|
_ids: &[UserId],
|
|
_p: &PageParams,
|
|
_v: Option<&UserId>,
|
|
) -> Result<Paginated<FeedEntry>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
async fn public_feed(
|
|
&self,
|
|
_p: &PageParams,
|
|
_v: Option<&UserId>,
|
|
) -> Result<Paginated<FeedEntry>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
async fn search(
|
|
&self,
|
|
_q: &str,
|
|
_p: &PageParams,
|
|
_v: Option<&UserId>,
|
|
) -> Result<Paginated<FeedEntry>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
async fn tag_feed(
|
|
&self,
|
|
_tag_name: &str,
|
|
_page: &PageParams,
|
|
_viewer_id: Option<&UserId>,
|
|
) -> Result<Paginated<FeedEntry>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
async fn user_feed(
|
|
&self,
|
|
_user_id: &UserId,
|
|
_page: &PageParams,
|
|
_viewer_id: Option<&UserId>,
|
|
) -> Result<Paginated<FeedEntry>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl SearchPort for TestStore {
|
|
async fn search_thoughts(
|
|
&self,
|
|
_q: &str,
|
|
_p: &PageParams,
|
|
_v: Option<&UserId>,
|
|
) -> Result<Paginated<FeedEntry>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
async fn search_users(
|
|
&self,
|
|
_q: &str,
|
|
_p: &PageParams,
|
|
) -> Result<Paginated<User>, DomainError> {
|
|
Ok(Paginated {
|
|
items: vec![],
|
|
total: 0,
|
|
page: 1,
|
|
per_page: 20,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl ActivityPubRepository for TestStore {
|
|
async fn outbox_entries_for_actor(
|
|
&self,
|
|
_uid: &UserId,
|
|
) -> Result<Vec<crate::ports::OutboxEntry>, DomainError> {
|
|
Ok(vec![])
|
|
}
|
|
async fn outbox_page_for_actor(
|
|
&self,
|
|
_uid: &UserId,
|
|
_before: Option<chrono::DateTime<chrono::Utc>>,
|
|
_limit: usize,
|
|
) -> Result<Vec<crate::ports::OutboxEntry>, DomainError> {
|
|
Ok(vec![])
|
|
}
|
|
async fn find_remote_actor_id(
|
|
&self,
|
|
actor_ap_url: &url::Url,
|
|
) -> Result<Option<UserId>, DomainError> {
|
|
let url = actor_ap_url.to_string();
|
|
Ok(self
|
|
.users
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.find(|u| u.ap_id.as_deref() == Some(&url))
|
|
.map(|u| u.id.clone()))
|
|
}
|
|
async fn intern_remote_actor(&self, actor_ap_url: &url::Url) -> Result<UserId, DomainError> {
|
|
if let Some(uid) = self.find_remote_actor_id(actor_ap_url).await? {
|
|
return Ok(uid);
|
|
}
|
|
let uid = UserId::new();
|
|
let handle = actor_ap_url
|
|
.path()
|
|
.trim_start_matches('/')
|
|
.replace('/', "_");
|
|
let user = crate::models::user::User {
|
|
id: uid.clone(),
|
|
username: Username::from_trusted(handle.clone()),
|
|
email: Email::from_trusted(format!("{}@remote", uid)),
|
|
password_hash: PasswordHash("".into()),
|
|
display_name: None,
|
|
bio: None,
|
|
avatar_url: None,
|
|
header_url: None,
|
|
custom_css: None,
|
|
local: false,
|
|
ap_id: Some(actor_ap_url.to_string()),
|
|
inbox_url: None,
|
|
public_key: None,
|
|
private_key: None,
|
|
created_at: chrono::Utc::now(),
|
|
updated_at: chrono::Utc::now(),
|
|
};
|
|
self.users.lock().unwrap().push(user);
|
|
Ok(uid)
|
|
}
|
|
async fn accept_note(
|
|
&self,
|
|
_ap_id: &url::Url,
|
|
_author_id: &UserId,
|
|
_content: &str,
|
|
_published: chrono::DateTime<chrono::Utc>,
|
|
_sensitive: bool,
|
|
_content_warning: Option<String>,
|
|
_visibility: &str,
|
|
) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
async fn apply_note_update(
|
|
&self,
|
|
_ap_id: &url::Url,
|
|
_new_content: &str,
|
|
) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
async fn retract_note(&self, _ap_id: &url::Url) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
async fn retract_actor_notes(&self, _actor_ap_url: &url::Url) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
async fn count_local_notes(&self) -> Result<u64, DomainError> {
|
|
Ok(self
|
|
.thoughts
|
|
.lock()
|
|
.unwrap()
|
|
.iter()
|
|
.filter(|t| t.local)
|
|
.count() as u64)
|
|
}
|
|
}
|
|
|
|
#[async_trait]
|
|
impl EventPublisher for TestStore {
|
|
async fn publish(&self, event: &DomainEvent) -> Result<(), DomainError> {
|
|
self.events.lock().unwrap().push(event.clone());
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub struct NoOpEventPublisher;
|
|
#[async_trait]
|
|
impl EventPublisher for NoOpEventPublisher {
|
|
async fn publish(&self, _e: &DomainEvent) -> Result<(), DomainError> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod ap_repo_tests {
|
|
use super::*;
|
|
use crate::value_objects::UserId;
|
|
|
|
#[tokio::test]
|
|
async fn test_store_outbox_returns_empty() {
|
|
let store = TestStore::default();
|
|
let result = store
|
|
.outbox_entries_for_actor(&UserId::new())
|
|
.await
|
|
.unwrap();
|
|
assert!(result.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_store_intern_creates_placeholder() {
|
|
let store = TestStore::default();
|
|
let url = url::Url::parse("https://example.com/users/alice").unwrap();
|
|
let id1 = store.intern_remote_actor(&url).await.unwrap();
|
|
let id2 = store.intern_remote_actor(&url).await.unwrap();
|
|
assert_eq!(id1, id2, "intern must be idempotent");
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod federation_port_tests {
|
|
use super::*;
|
|
use crate::value_objects::UserId;
|
|
|
|
fn uid() -> UserId {
|
|
UserId::new()
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_store_lookup_returns_not_found() {
|
|
let store = TestStore::default();
|
|
let err = store.lookup_actor("@alice@example.com").await.unwrap_err();
|
|
assert!(matches!(err, DomainError::NotFound));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_store_follow_remote_is_noop_ok() {
|
|
let store = TestStore::default();
|
|
store
|
|
.follow_remote(&uid(), "@alice@example.com")
|
|
.await
|
|
.unwrap();
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_store_actor_json_returns_not_found() {
|
|
let store = TestStore::default();
|
|
let err = store.actor_json(&UserId::new()).await.unwrap_err();
|
|
assert!(matches!(err, DomainError::NotFound));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_store_fetch_outbox_returns_empty() {
|
|
let store = TestStore::default();
|
|
let notes = store
|
|
.fetch_outbox_page("https://example.com/outbox", 1)
|
|
.await
|
|
.unwrap();
|
|
assert!(notes.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_store_resolve_actor_profiles_returns_empty() {
|
|
let store = TestStore::default();
|
|
let result = store
|
|
.resolve_actor_profiles(vec!["https://example.com/users/alice".into()])
|
|
.await;
|
|
assert!(result.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_store_fetch_collection_urls_returns_empty() {
|
|
let store = TestStore::default();
|
|
let urls = store
|
|
.fetch_actor_urls_from_collection("https://example.com/users/alice/followers")
|
|
.await
|
|
.unwrap();
|
|
assert!(urls.is_empty());
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod search_tests {
|
|
use super::*;
|
|
use crate::models::feed::PageParams;
|
|
|
|
#[tokio::test]
|
|
async fn test_store_search_thoughts_returns_empty() {
|
|
let store = TestStore::default();
|
|
let result = store
|
|
.search_thoughts(
|
|
"hello",
|
|
&PageParams {
|
|
page: 1,
|
|
per_page: 20,
|
|
},
|
|
None,
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(result.total, 0);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn test_store_search_users_returns_empty() {
|
|
let store = TestStore::default();
|
|
let result = store
|
|
.search_users(
|
|
"alice",
|
|
&PageParams {
|
|
page: 1,
|
|
per_page: 20,
|
|
},
|
|
)
|
|
.await
|
|
.unwrap();
|
|
assert_eq!(result.total, 0);
|
|
}
|
|
}
|