LemmyNet/lemmy
2
0
Fork 0
mirror of https://github.com/LemmyNet/lemmy.git synced 2024-10-30 17:20:02 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Replace clippy::unwrap_used in tests (#5064)

Browse source 
* Add LemmyResult to session_middleware tests

* Add LemmyResult to inboxes tests

* Add LemmyResult to slurs tests

* Add LemmyResult to markdown tests

* Add LemmyResult to rate_limiter tests

* Add LemmyResult to error tests

* Add LemmyResult to api_common utils tests

* Add LemmyResult to request tests

* Add LemmyResult to claims tests

* Propagate registration_applications errors

* Remove clippy::unwrap_used from community tests

* Add LemmyResult to community_view tests

* Add LemmyResult to db_schema post tests

* Add LemmyResult to site_aggregates tests

* Add LemmyResult to private_message tests

* Add LemmyResult to activity tests

* Add LemmyResult to federation_allowlist tests

* Add LemmyResult to comment_aggregates tests

* Add LemmyResult to post_report tests

* Add LemmyResult to moderator tests

* Add LemmyResult to community_aggregates tests

* Add LemmyResult to person_aggregates tests

* Add LemmyResult to language tests

* Add LemmyResult to post_aggregates tests

* Add LemmyResult to db_schema comment tests

* Add LemmyResult to actor_language tests

* Add LemmyResult to vote_view tests

* Add LemmyResult to registration_application_view tests

* Add LemmyResult to private_message_view tests

* Add LemmyResult to private_message_report_view tests

* Add LemmyResult to post_report_view tests

* Add LemmyResult to comment_report_view tests

* Add LemmyResult to sitemap tests

* Replace .expect() with .unwrap()

* Format code

* Remove clippy::unwrap_used from activity tests

* Add diesel result in db_schema tests

* Format code

* Map to_bytes() error to LemmyErrorType

* Remove clippy::unwrap_used from error tests

* Removing a few more unwraps, and cleaning up language code.

* Replace map_err with unwrap_or_default

* Replace ok_or with and_then

---------

Co-authored-by: Dessalines <tyhou13@gmx.com>
This commit is contained in:
netbrum 2024-10-02 12:50:21 +00:00 committed by GitHub
parent ffb94fde85
commit 483bdd592e
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
42 changed files with 882 additions and 1220 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
crates/api/src/site/registration_applications/tests.rs
View file

@ -34,13 +34,10 @@ use lemmy_db_views::structs::LocalUserView;
use lemmy_utils::{error::LemmyResult, LemmyErrorType, CACHE_DURATION_API};
use serial_test::serial;
#[expect(clippy::unwrap_used)]
async fn create_test_site(context: &Data<LemmyContext>) -> LemmyResult<(Instance, LocalUserView)> {
let pool = &mut context.pool();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.expect("Create test instance");
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let admin_person = Person::create(
pool,
@ -57,7 +54,7 @@ async fn create_test_site(context: &Data<LemmyContext>) -> LemmyResult<(Instance
let admin_local_user_view = LocalUserView::read_person(pool, admin_person.id).await?;
let site_form = SiteInsertForm::new("test site".to_string(), inserted_instance.id);
let site = Site::create(pool, &site_form).await.unwrap();
let site = Site::create(pool, &site_form).await?;
// Create a local site, since this is necessary for determining if email verification is
// required
@ -68,14 +65,12 @@ async fn create_test_site(context: &Data<LemmyContext>) -> LemmyResult<(Instance
site_setup: Some(true),
..LocalSiteInsertForm::new(site.id)
};
let local_site = LocalSite::create(pool, &local_site_form).await.unwrap();
let local_site = LocalSite::create(pool, &local_site_form).await?;
// Required to have a working local SiteView when updating the site to change email verification
// requirement or registration mode
let rate_limit_form = LocalSiteRateLimitInsertForm::new(local_site.id);
LocalSiteRateLimit::create(pool, &rate_limit_form)
.await
.unwrap();
LocalSiteRateLimit::create(pool, &rate_limit_form).await?;
Ok((inserted_instance, admin_local_user_view))
}
@ -109,7 +104,6 @@ async fn signup(
Ok((local_user, application))
}
#[expect(clippy::unwrap_used)]
async fn get_application_statuses(
context: &Data<LemmyContext>,
admin: LocalUserView,
@ -122,14 +116,14 @@ async fn get_application_statuses(
get_unread_registration_application_count(context.reset_request_count(), admin.clone()).await?;
let unread_applications = list_registration_applications(
Query::from_query("unread_only=true").unwrap(),
Query::from_query("unread_only=true")?,
context.reset_request_count(),
admin.clone(),
)
.await?;
let all_applications = list_registration_applications(
Query::from_query("unread_only=false").unwrap(),
Query::from_query("unread_only=false")?,
context.reset_request_count(),
admin,
)

58
crates/api/src/sitemap.rs
View file

@ -42,44 +42,40 @@ pub async fn get_sitemap(context: Data<LemmyContext>) -> LemmyResult<HttpRespons
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
pub(crate) mod tests {
use crate::sitemap::generate_urlset;
use chrono::{DateTime, NaiveDate, Utc};
use elementtree::Element;
use lemmy_db_schema::newtypes::DbUrl;
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use url::Url;
#[tokio::test]
async fn test_generate_urlset() {
async fn test_generate_urlset() -> LemmyResult<()> {
let posts: Vec<(DbUrl, DateTime<Utc>)> = vec![
(
Url::parse("https://example.com").unwrap().into(),
Url::parse("https://example.com")?.into(),
NaiveDate::from_ymd_opt(2022, 12, 1)
.unwrap()
.unwrap_or_default()
.and_hms_opt(9, 10, 11)
.unwrap()
.unwrap_or_default()
.and_utc(),
),
(
Url::parse("https://lemmy.ml").unwrap().into(),
Url::parse("https://lemmy.ml")?.into(),
NaiveDate::from_ymd_opt(2023, 1, 1)
.unwrap()
.unwrap_or_default()
.and_hms_opt(1, 2, 3)
.unwrap()
.unwrap_or_default()
.and_utc(),
),
];
let mut buf = Vec::<u8>::new();
generate_urlset(posts)
.await
.unwrap()
.write(&mut buf)
.unwrap();
let root = Element::from_reader(buf.as_slice()).unwrap();
generate_urlset(posts).await?.write(&mut buf)?;
let root = Element::from_reader(buf.as_slice())?;
assert_eq!(root.tag().name(), "urlset");
assert_eq!(root.child_count(), 2);
@ -99,45 +95,43 @@ pub(crate) mod tests {
root
.children()
.next()
.unwrap()
.children()
.find(|element| element.tag().name() == "loc")
.unwrap()
.text(),
.and_then(|n| n.children().find(|element| element.tag().name() == "loc"))
.map(Element::text)
.unwrap_or_default(),
"https://example.com/"
);
assert_eq!(
root
.children()
.next()
.unwrap()
.and_then(|n| n
.children()
.find(|element| element.tag().name() == "lastmod")
.unwrap()
.text(),
.find(|element| element.tag().name() == "lastmod"))
.map(Element::text)
.unwrap_or_default(),
"2022-12-01T09:10:11+00:00"
);
assert_eq!(
root
.children()
.nth(1)
.unwrap()
.children()
.find(|element| element.tag().name() == "loc")
.unwrap()
.text(),
.and_then(|n| n.children().find(|element| element.tag().name() == "loc"))
.map(Element::text)
.unwrap_or_default(),
"https://lemmy.ml/"
);
assert_eq!(
root
.children()
.nth(1)
.unwrap()
.and_then(|n| n
.children()
.find(|element| element.tag().name() == "lastmod")
.unwrap()
.text(),
.find(|element| element.tag().name() == "lastmod"))
.map(Element::text)
.unwrap_or_default(),
"2023-01-01T01:02:03+00:00"
);
Ok(())
}
}

25
crates/api_common/src/claims.rs
View file

@ -69,7 +69,6 @@ impl Claims {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{claims::Claims, context::LemmyContext};
@ -84,7 +83,7 @@ mod tests {
traits::Crud,
utils::build_db_pool_for_tests,
};
use lemmy_utils::rate_limit::RateLimitCell;
use lemmy_utils::{error::LemmyResult, rate_limit::RateLimitCell};
use pretty_assertions::assert_eq;
use reqwest::Client;
use reqwest_middleware::ClientBuilder;
@ -92,10 +91,10 @@ mod tests {
#[tokio::test]
#[serial]
async fn test_should_not_validate_user_token_after_password_change() {
async fn test_should_not_validate_user_token_after_password_change() -> LemmyResult<()> {
let pool_ = build_db_pool_for_tests().await;
let pool = &mut (&pool_).into();
let secret = Secret::init(pool).await.unwrap().unwrap();
let secret = Secret::init(pool).await?;
let context = LemmyContext::create(
pool_.clone(),
ClientBuilder::new(Client::default()).build(),
@ -103,29 +102,25 @@ mod tests {
RateLimitCell::with_test_config(),
);
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "Gerry9812");
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let local_user_form = LocalUserInsertForm::test_form(inserted_person.id);
let inserted_local_user = LocalUser::create(pool, &local_user_form, vec![])
.await
.unwrap();
let inserted_local_user = LocalUser::create(pool, &local_user_form, vec![]).await?;
let req = TestRequest::default().to_http_request();
let jwt = Claims::generate(inserted_local_user.id, req, &context)
.await
.unwrap();
let jwt = Claims::generate(inserted_local_user.id, req, &context).await?;
let valid = Claims::validate(&jwt, &context).await;
assert!(valid.is_ok());
let num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
let num_deleted = Person::delete(pool, inserted_person.id).await?;
assert_eq!(1, num_deleted);
Ok(())
}
}

31
crates/api_common/src/request.rs
View file

@ -471,13 +471,13 @@ pub async fn replace_image(
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
context::LemmyContext,
request::{extract_opengraph_data, fetch_link_metadata},
};
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
use url::Url;
@ -485,10 +485,10 @@ mod tests {
// These helped with testing
#[tokio::test]
#[serial]
async fn test_link_metadata() {
async fn test_link_metadata() -> LemmyResult<()> {
let context = LemmyContext::init_test_context().await;
let sample_url = Url::parse("https://gitlab.com/IzzyOnDroid/repo/-/wikis/FAQ").unwrap();
let sample_res = fetch_link_metadata(&sample_url, &context).await.unwrap();
let sample_url = Url::parse("https://gitlab.com/IzzyOnDroid/repo/-/wikis/FAQ")?;
let sample_res = fetch_link_metadata(&sample_url, &context).await?;
assert_eq!(
Some("FAQ · Wiki · IzzyOnDroid / repo · GitLab".to_string()),
sample_res.opengraph_data.title
@ -499,8 +499,7 @@ mod tests {
);
assert_eq!(
Some(
Url::parse("https://gitlab.com/uploads/-/system/project/avatar/4877469/iod_logo.png")
.unwrap()
Url::parse("https://gitlab.com/uploads/-/system/project/avatar/4877469/iod_logo.png")?
.into()
),
sample_res.opengraph_data.image
@ -510,19 +509,21 @@ mod tests {
Some(mime::TEXT_HTML_UTF_8.to_string()),
sample_res.content_type
);
Ok(())
}
#[test]
fn test_resolve_image_url() {
fn test_resolve_image_url() -> LemmyResult<()> {
// url that lists the opengraph fields
let url = Url::parse("https://example.com/one/two.html").unwrap();
let url = Url::parse("https://example.com/one/two.html")?;
// root relative url
let html_bytes = b"<!DOCTYPE html><html><head><meta property='og:image' content='/image.jpg'></head><body></body></html>";
let metadata = extract_opengraph_data(html_bytes, &url).expect("Unable to parse metadata");
assert_eq!(
metadata.image,
Some(Url::parse("https://example.com/image.jpg").unwrap().into())
Some(Url::parse("https://example.com/image.jpg")?.into())
);
// base relative url
@ -530,11 +531,7 @@ mod tests {
let metadata = extract_opengraph_data(html_bytes, &url).expect("Unable to parse metadata");
assert_eq!(
metadata.image,
Some(
Url::parse("https://example.com/one/image.jpg")
.unwrap()
.into()
)
Some(Url::parse("https://example.com/one/image.jpg")?.into())
);
// absolute url
@ -542,7 +539,7 @@ mod tests {
let metadata = extract_opengraph_data(html_bytes, &url).expect("Unable to parse metadata");
assert_eq!(
metadata.image,
Some(Url::parse("https://cdn.host.com/image.jpg").unwrap().into())
Some(Url::parse("https://cdn.host.com/image.jpg")?.into())
);
// protocol relative url
@ -550,7 +547,9 @@ mod tests {
let metadata = extract_opengraph_data(html_bytes, &url).expect("Unable to parse metadata");
assert_eq!(
metadata.image,
Some(Url::parse("https://example.com/image.jpg").unwrap().into())
Some(Url::parse("https://example.com/image.jpg")?.into())
);
Ok(())
}
}

14
crates/api_crud/src/comment/create.rs
View file

@ -88,16 +88,9 @@ pub async fn create_comment(
check_comment_depth(parent)?;
}
CommunityLanguage::is_allowed_community_language(
&mut context.pool(),
data.language_id,
community_id,
)
.await?;
// attempt to set default language if none was provided
let language_id = match data.language_id {
Some(lid) => Some(lid),
Some(lid) => lid,
None => {
default_post_language(
&mut context.pool(),
@ -108,8 +101,11 @@ pub async fn create_comment(
}
};
CommunityLanguage::is_allowed_community_language(&mut context.pool(), language_id, community_id)
.await?;
let comment_form = CommentInsertForm {
language_id,
language_id: Some(language_id),
..CommentInsertForm::new(local_user_view.person.id, data.post_id, content.clone())
};

3
crates/api_crud/src/comment/update.rs
View file

@ -55,13 +55,14 @@ pub async fn update_comment(
Err(LemmyErrorType::NoCommentEditAllowed)?
}
let language_id = data.language_id;
if let Some(language_id) = data.language_id {
CommunityLanguage::is_allowed_community_language(
&mut context.pool(),
language_id,
orig_comment.community.id,
)
.await?;
}
let slur_regex = local_site_to_slur_regex(&local_site);
let url_blocklist = get_url_blocklist(&context).await?;

18
crates/api_crud/src/post/create.rs
View file

@ -104,18 +104,9 @@ pub async fn create_post(
.await?;
}
// Only need to check if language is allowed in case user set it explicitly. When using default
// language, it already only returns allowed languages.
CommunityLanguage::is_allowed_community_language(
&mut context.pool(),
data.language_id,
community_id,
)
.await?;
// attempt to set default language if none was provided
let language_id = match data.language_id {
Some(lid) => Some(lid),
Some(lid) => lid,
None => {
default_post_language(
&mut context.pool(),
@ -126,6 +117,11 @@ pub async fn create_post(
}
};
// Only need to check if language is allowed in case user set it explicitly. When using default
// language, it already only returns allowed languages.
CommunityLanguage::is_allowed_community_language(&mut context.pool(), language_id, community_id)
.await?;
let scheduled_publish_time =
convert_published_time(data.scheduled_publish_time, &local_user_view, &context).await?;
let post_form = PostInsertForm {
@ -133,7 +129,7 @@ pub async fn create_post(
body,
alt_text: data.alt_text.clone(),
nsfw: data.nsfw,
language_id,
language_id: Some(language_id),
scheduled_publish_time,
..PostInsertForm::new(
data.name.trim().to_string(),

3
crates/api_crud/src/post/update.rs
View file

@ -101,13 +101,14 @@ pub async fn update_post(
Err(LemmyErrorType::NoPostEditAllowed)?
}
let language_id = data.language_id;
if let Some(language_id) = data.language_id {
CommunityLanguage::is_allowed_community_language(
&mut context.pool(),
language_id,
orig_post.community_id,
)
.await?;
}
// handle changes to scheduled_publish_time
let scheduled_publish_time = match (

3
crates/apub/src/http/community.rs
View file

@ -120,7 +120,6 @@ pub(crate) async fn get_apub_community_featured(
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
pub(crate) mod tests {
use super::*;
@ -182,7 +181,7 @@ pub(crate) mod tests {
}
async fn decode_response<T: DeserializeOwned>(res: HttpResponse) -> LemmyResult<T> {
let body = to_bytes(res.into_body()).await.unwrap();
let body = to_bytes(res.into_body()).await.unwrap_or_default();
let body = std::str::from_utf8(&body)?;
Ok(serde_json::from_str(body)?)
}

8
crates/apub/src/objects/comment.rs
View file

@ -104,7 +104,7 @@ impl Object for ApubComment {
} else {
post.ap_id.into()
};
let language = LanguageTag::new_single(self.language_id, &mut context.pool()).await?;
let language = Some(LanguageTag::new_single(self.language_id, &mut context.pool()).await?);
let maa = collect_non_local_mentions(&self, community.actor_id.clone().into(), context).await?;
let note = Note {
@ -181,8 +181,10 @@ impl Object for ApubComment {
let slur_regex = &local_site_opt_to_slur_regex(&local_site);
let url_blocklist = get_url_blocklist(context).await?;
let content = process_markdown(&content, slur_regex, &url_blocklist, context).await?;
let language_id =
LanguageTag::to_language_id_single(note.language, &mut context.pool()).await?;
let language_id = Some(
LanguageTag::to_language_id_single(note.language.unwrap_or_default(), &mut context.pool())
.await?,
);
let form = CommentInsertForm {
creator_id: creator.id,

8
crates/apub/src/objects/post.rs
View file

@ -110,7 +110,7 @@ impl Object for ApubPost {
let creator = Person::read(&mut context.pool(), creator_id).await?;
let community_id = self.community_id;
let community = Community::read(&mut context.pool(), community_id).await?;
let language = LanguageTag::new_single(self.language_id, &mut context.pool()).await?;
let language = Some(LanguageTag::new_single(self.language_id, &mut context.pool()).await?);
let attachment = self
.url
@ -237,8 +237,10 @@ impl Object for ApubPost {
let body = read_from_string_or_source_opt(&page.content, &page.media_type, &page.source);
let body = process_markdown_opt(&body, slur_regex, &url_blocklist, context).await?;
let language_id =
LanguageTag::to_language_id_single(page.language, &mut context.pool()).await?;
let language_id = Some(
LanguageTag::to_language_id_single(page.language.unwrap_or_default(), &mut context.pool())
.await?,
);
let form = PostInsertForm {
url: url.map(Into::into),

30
crates/apub/src/protocol/objects/mod.rs
View file

@ -30,21 +30,30 @@ pub(crate) struct LanguageTag {
pub(crate) name: String,
}
impl Default for LanguageTag {
fn default() -> Self {
LanguageTag {
identifier: "und".to_string(),
name: "Undetermined".to_string(),
}
}
}
impl LanguageTag {
pub(crate) async fn new_single(
lang: LanguageId,
pool: &mut DbPool<'_>,
) -> LemmyResult<Option<LanguageTag>> {
) -> LemmyResult<LanguageTag> {
let lang = Language::read_from_id(pool, lang).await?;
// undetermined
if lang.id == UNDETERMINED_ID {
Ok(None)
Ok(LanguageTag::default())
} else {
Ok(Some(LanguageTag {
Ok(LanguageTag {
identifier: lang.code,
name: lang.name,
}))
})
}
}
@ -69,13 +78,10 @@ impl LanguageTag {
}
pub(crate) async fn to_language_id_single(
lang: Option<Self>,
lang: Self,
pool: &mut DbPool<'_>,
) -> LemmyResult<Option<LanguageId>> {
let identifier = lang.map(|l| l.identifier);
let language = Language::read_id_from_code(pool, identifier.as_deref()).await?;
Ok(language)
) -> LemmyResult<LanguageId> {
Ok(Language::read_id_from_code(pool, &lang.identifier).await?)
}
pub(crate) async fn to_language_id_multiple(
@ -86,10 +92,10 @@ impl LanguageTag {
for l in langs {
let id = l.identifier;
language_ids.push(Language::read_id_from_code(pool, Some(&id)).await?);
language_ids.push(Language::read_id_from_code(pool, &id).await?);
}
Ok(language_ids.into_iter().flatten().collect())
Ok(language_ids.into_iter().collect())
}
}

58
crates/db_schema/src/aggregates/comment_aggregates.rs
View file

@ -30,7 +30,6 @@ impl CommentAggregates {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
@ -45,26 +44,25 @@ mod tests {
traits::{Crud, Likeable},
utils::build_db_pool_for_tests,
};
use diesel::result::Error;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "thommy_comment_agg");
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let another_person = PersonInsertForm::test_form(inserted_instance.id, "jerry_comment_agg");
let another_inserted_person = Person::create(pool, &another_person).await.unwrap();
let another_inserted_person = Person::create(pool, &another_person).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -72,21 +70,21 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
let new_post = PostInsertForm::new(
"A test post".into(),
inserted_person.id,
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
let comment_form = CommentInsertForm::new(
inserted_person.id,
inserted_post.id,
"A test comment".into(),
);
let inserted_comment = Comment::create(pool, &comment_form, None).await.unwrap();
let inserted_comment = Comment::create(pool, &comment_form, None).await?;
let child_comment_form = CommentInsertForm::new(
inserted_person.id,
@ -94,9 +92,7 @@ mod tests {
"A test comment".into(),
);
let _inserted_child_comment =
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path))
.await
.unwrap();
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path)).await?;
let comment_like = CommentLikeForm {
comment_id: inserted_comment.id,
@ -105,11 +101,9 @@ mod tests {
score: 1,
};
CommentLike::like(pool, &comment_like).await.unwrap();
CommentLike::like(pool, &comment_like).await?;
let comment_aggs_before_delete = CommentAggregates::read(pool, inserted_comment.id)
.await
.unwrap();
let comment_aggs_before_delete = CommentAggregates::read(pool, inserted_comment.id).await?;
assert_eq!(1, comment_aggs_before_delete.score);
assert_eq!(1, comment_aggs_before_delete.upvotes);
@ -123,47 +117,39 @@ mod tests {
score: -1,
};
CommentLike::like(pool, &comment_dislike).await.unwrap();
CommentLike::like(pool, &comment_dislike).await?;
let comment_aggs_after_dislike = CommentAggregates::read(pool, inserted_comment.id)
.await
.unwrap();
let comment_aggs_after_dislike = CommentAggregates::read(pool, inserted_comment.id).await?;
assert_eq!(0, comment_aggs_after_dislike.score);
assert_eq!(1, comment_aggs_after_dislike.upvotes);
assert_eq!(1, comment_aggs_after_dislike.downvotes);
// Remove the first comment like
CommentLike::remove(pool, inserted_person.id, inserted_comment.id)
.await
.unwrap();
let after_like_remove = CommentAggregates::read(pool, inserted_comment.id)
.await
.unwrap();
CommentLike::remove(pool, inserted_person.id, inserted_comment.id).await?;
let after_like_remove = CommentAggregates::read(pool, inserted_comment.id).await?;
assert_eq!(-1, after_like_remove.score);
assert_eq!(0, after_like_remove.upvotes);
assert_eq!(1, after_like_remove.downvotes);
// Remove the parent post
Post::delete(pool, inserted_post.id).await.unwrap();
Post::delete(pool, inserted_post.id).await?;
// Should be none found, since the post was deleted
let after_delete = CommentAggregates::read(pool, inserted_comment.id).await;
assert!(after_delete.is_err());
// This should delete all the associated rows, and fire triggers
Person::delete(pool, another_inserted_person.id)
.await
.unwrap();
let person_num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
Person::delete(pool, another_inserted_person.id).await?;
let person_num_deleted = Person::delete(pool, inserted_person.id).await?;
assert_eq!(1, person_num_deleted);
// Delete the community
let community_num_deleted = Community::delete(pool, inserted_community.id)
.await
.unwrap();
let community_num_deleted = Community::delete(pool, inserted_community.id).await?;
assert_eq!(1, community_num_deleted);
Instance::delete(pool, inserted_instance.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
}

108
crates/db_schema/src/aggregates/community_aggregates.rs
View file

@ -1,6 +1,5 @@
use crate::{
aggregates::structs::CommunityAggregates,
diesel::OptionalExtension,
newtypes::CommunityId,
schema::{community_aggregates, community_aggregates::subscribers},
utils::{get_conn, DbPool},
@ -9,16 +8,12 @@ use diesel::{result::Error, ExpressionMethods, QueryDsl};
use diesel_async::RunQueryDsl;
impl CommunityAggregates {
pub async fn read(
pool: &mut DbPool<'_>,
for_community_id: CommunityId,
) -> Result<Option<Self>, Error> {
pub async fn read(pool: &mut DbPool<'_>, for_community_id: CommunityId) -> Result<Self, Error> {
let conn = &mut get_conn(pool).await?;
community_aggregates::table
.find(for_community_id)
.first(conn)
.await
.optional()
}
pub async fn update_federated_followers(
@ -36,7 +31,6 @@ impl CommunityAggregates {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
@ -51,26 +45,25 @@ mod tests {
traits::{Crud, Followable},
utils::build_db_pool_for_tests,
};
use diesel::result::Error;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "thommy_community_agg");
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let another_person = PersonInsertForm::test_form(inserted_instance.id, "jerry_community_agg");
let another_inserted_person = Person::create(pool, &another_person).await.unwrap();
let another_inserted_person = Person::create(pool, &another_person).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -78,7 +71,7 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
let another_community = CommunityInsertForm::new(
inserted_instance.id,
@ -86,7 +79,7 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let another_inserted_community = Community::create(pool, &another_community).await.unwrap();
let another_inserted_community = Community::create(pool, &another_community).await?;
let first_person_follow = CommunityFollowerForm {
community_id: inserted_community.id,
@ -94,9 +87,7 @@ mod tests {
pending: false,
};
CommunityFollower::follow(pool, &first_person_follow)
.await
.unwrap();
CommunityFollower::follow(pool, &first_person_follow).await?;
let second_person_follow = CommunityFollowerForm {
community_id: inserted_community.id,
@ -104,9 +95,7 @@ mod tests {
pending: false,
};
CommunityFollower::follow(pool, &second_person_follow)
.await
.unwrap();
CommunityFollower::follow(pool, &second_person_follow).await?;
let another_community_follow = CommunityFollowerForm {
community_id: another_inserted_community.id,
@ -114,23 +103,21 @@ mod tests {
pending: false,
};
CommunityFollower::follow(pool, &another_community_follow)
.await
.unwrap();
CommunityFollower::follow(pool, &another_community_follow).await?;
let new_post = PostInsertForm::new(
"A test post".into(),
inserted_person.id,
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
let comment_form = CommentInsertForm::new(
inserted_person.id,
inserted_post.id,
"A test comment".into(),
);
let inserted_comment = Comment::create(pool, &comment_form, None).await.unwrap();
let inserted_comment = Comment::create(pool, &comment_form, None).await?;
let child_comment_form = CommentInsertForm::new(
inserted_person.id,
@ -138,14 +125,10 @@ mod tests {
"A test comment".into(),
);
let _inserted_child_comment =
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path))
.await
.unwrap();
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path)).await?;
let community_aggregates_before_delete = CommunityAggregates::read(pool, inserted_community.id)
.await
.unwrap()
.unwrap();
let community_aggregates_before_delete =
CommunityAggregates::read(pool, inserted_community.id).await?;
assert_eq!(2, community_aggregates_before_delete.subscribers);
assert_eq!(2, community_aggregates_before_delete.subscribers_local);
@ -153,76 +136,53 @@ mod tests {
assert_eq!(2, community_aggregates_before_delete.comments);
// Test the other community
let another_community_aggs = CommunityAggregates::read(pool, another_inserted_community.id)
.await
.unwrap()
.unwrap();
let another_community_aggs =
CommunityAggregates::read(pool, another_inserted_community.id).await?;
assert_eq!(1, another_community_aggs.subscribers);
assert_eq!(1, another_community_aggs.subscribers_local);
assert_eq!(0, another_community_aggs.posts);
assert_eq!(0, another_community_aggs.comments);
// Unfollow test
CommunityFollower::unfollow(pool, &second_person_follow)
.await
.unwrap();
let after_unfollow = CommunityAggregates::read(pool, inserted_community.id)
.await
.unwrap()
.unwrap();
CommunityFollower::unfollow(pool, &second_person_follow).await?;
let after_unfollow = CommunityAggregates::read(pool, inserted_community.id).await?;
assert_eq!(1, after_unfollow.subscribers);
assert_eq!(1, after_unfollow.subscribers_local);
// Follow again just for the later tests
CommunityFollower::follow(pool, &second_person_follow)
.await
.unwrap();
let after_follow_again = CommunityAggregates::read(pool, inserted_community.id)
.await
.unwrap()
.unwrap();
CommunityFollower::follow(pool, &second_person_follow).await?;
let after_follow_again = CommunityAggregates::read(pool, inserted_community.id).await?;
assert_eq!(2, after_follow_again.subscribers);
assert_eq!(2, after_follow_again.subscribers_local);
// Remove a parent post (the comment count should also be 0)
Post::delete(pool, inserted_post.id).await.unwrap();
let after_parent_post_delete = CommunityAggregates::read(pool, inserted_community.id)
.await
.unwrap()
.unwrap();
Post::delete(pool, inserted_post.id).await?;
let after_parent_post_delete = CommunityAggregates::read(pool, inserted_community.id).await?;
assert_eq!(0, after_parent_post_delete.comments);
assert_eq!(0, after_parent_post_delete.posts);
// Remove the 2nd person
Person::delete(pool, another_inserted_person.id)
.await
.unwrap();
let after_person_delete = CommunityAggregates::read(pool, inserted_community.id)
.await
.unwrap()
.unwrap();
Person::delete(pool, another_inserted_person.id).await?;
let after_person_delete = CommunityAggregates::read(pool, inserted_community.id).await?;
assert_eq!(1, after_person_delete.subscribers);
assert_eq!(1, after_person_delete.subscribers_local);
// This should delete all the associated rows, and fire triggers
let person_num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
let person_num_deleted = Person::delete(pool, inserted_person.id).await?;
assert_eq!(1, person_num_deleted);
// Delete the community
let community_num_deleted = Community::delete(pool, inserted_community.id)
.await
.unwrap();
let community_num_deleted = Community::delete(pool, inserted_community.id).await?;
assert_eq!(1, community_num_deleted);
let another_community_num_deleted = Community::delete(pool, another_inserted_community.id)
.await
.unwrap();
let another_community_num_deleted =
Community::delete(pool, another_inserted_community.id).await?;
assert_eq!(1, another_community_num_deleted);
// Should be none found, since the creator was deleted
let after_delete = CommunityAggregates::read(pool, inserted_community.id)
.await
.unwrap();
assert!(after_delete.is_none());
let after_delete = CommunityAggregates::read(pool, inserted_community.id).await;
assert!(after_delete.is_err());
Ok(())
}
}

113
crates/db_schema/src/aggregates/person_aggregates.rs
View file

@ -1,4 +1,3 @@
pub(crate) use crate::diesel::OptionalExtension;
use crate::{
aggregates::structs::PersonAggregates,
newtypes::PersonId,
@ -9,18 +8,13 @@ use diesel::{result::Error, QueryDsl};
use diesel_async::RunQueryDsl;
impl PersonAggregates {
pub async fn read(pool: &mut DbPool<'_>, person_id: PersonId) -> Result<Option<Self>, Error> {
pub async fn read(pool: &mut DbPool<'_>, person_id: PersonId) -> Result<Self, Error> {
let conn = &mut get_conn(pool).await?;
person_aggregates::table
.find(person_id)
.first(conn)
.await
.optional()
person_aggregates::table.find(person_id).first(conn).await
}
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
@ -35,26 +29,25 @@ mod tests {
traits::{Crud, Likeable},
utils::build_db_pool_for_tests,
};
use diesel::result::Error;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "thommy_user_agg");
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let another_person = PersonInsertForm::test_form(inserted_instance.id, "jerry_user_agg");
let another_inserted_person = Person::create(pool, &another_person).await.unwrap();
let another_inserted_person = Person::create(pool, &another_person).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -63,28 +56,28 @@ mod tests {
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
let new_post = PostInsertForm::new(
"A test post".into(),
inserted_person.id,
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
let post_like = PostLikeForm {
post_id: inserted_post.id,
person_id: inserted_person.id,
score: 1,
};
let _inserted_post_like = PostLike::like(pool, &post_like).await.unwrap();
let _inserted_post_like = PostLike::like(pool, &post_like).await?;
let comment_form = CommentInsertForm::new(
inserted_person.id,
inserted_post.id,
"A test comment".into(),
);
let inserted_comment = Comment::create(pool, &comment_form, None).await.unwrap();
let inserted_comment = Comment::create(pool, &comment_form, None).await?;
let mut comment_like = CommentLikeForm {
comment_id: inserted_comment.id,
@ -93,7 +86,7 @@ mod tests {
score: 1,
};
let _inserted_comment_like = CommentLike::like(pool, &comment_like).await.unwrap();
let _inserted_comment_like = CommentLike::like(pool, &comment_like).await?;
let child_comment_form = CommentInsertForm::new(
inserted_person.id,
@ -101,9 +94,7 @@ mod tests {
"A test comment".into(),
);
let inserted_child_comment =
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path))
.await
.unwrap();
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path)).await?;
let child_comment_like = CommentLikeForm {
comment_id: inserted_child_comment.id,
@ -112,12 +103,9 @@ mod tests {
score: 1,
};
let _inserted_child_comment_like = CommentLike::like(pool, &child_comment_like).await.unwrap();
let _inserted_child_comment_like = CommentLike::like(pool, &child_comment_like).await?;
let person_aggregates_before_delete = PersonAggregates::read(pool, inserted_person.id)
.await
.unwrap()
.unwrap();
let person_aggregates_before_delete = PersonAggregates::read(pool, inserted_person.id).await?;
assert_eq!(1, person_aggregates_before_delete.post_count);
assert_eq!(1, person_aggregates_before_delete.post_score);
@ -125,13 +113,8 @@ mod tests {
assert_eq!(2, person_aggregates_before_delete.comment_score);
// Remove a post like
PostLike::remove(pool, inserted_person.id, inserted_post.id)
.await
.unwrap();
let after_post_like_remove = PersonAggregates::read(pool, inserted_person.id)
.await
.unwrap()
.unwrap();
PostLike::remove(pool, inserted_person.id, inserted_post.id).await?;
let after_post_like_remove = PersonAggregates::read(pool, inserted_person.id).await?;
assert_eq!(0, after_post_like_remove.post_score);
Comment::update(
@ -142,8 +125,7 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
Comment::update(
pool,
inserted_child_comment.id,
@ -152,51 +134,34 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let after_parent_comment_removed = PersonAggregates::read(pool, inserted_person.id)
.await
.unwrap()
.unwrap();
let after_parent_comment_removed = PersonAggregates::read(pool, inserted_person.id).await?;
assert_eq!(0, after_parent_comment_removed.comment_count);
// TODO: fix person aggregate comment score calculation
// assert_eq!(0, after_parent_comment_removed.comment_score);
// Remove a parent comment (the scores should also be removed)
Comment::delete(pool, inserted_comment.id).await.unwrap();
Comment::delete(pool, inserted_child_comment.id)
.await
.unwrap();
let after_parent_comment_delete = PersonAggregates::read(pool, inserted_person.id)
.await
.unwrap()
.unwrap();
Comment::delete(pool, inserted_comment.id).await?;
Comment::delete(pool, inserted_child_comment.id).await?;
let after_parent_comment_delete = PersonAggregates::read(pool, inserted_person.id).await?;
assert_eq!(0, after_parent_comment_delete.comment_count);
// TODO: fix person aggregate comment score calculation
// assert_eq!(0, after_parent_comment_delete.comment_score);
// Add in the two comments again, then delete the post.
let new_parent_comment = Comment::create(pool, &comment_form, None).await.unwrap();
let new_parent_comment = Comment::create(pool, &comment_form, None).await?;
let _new_child_comment =
Comment::create(pool, &child_comment_form, Some(&new_parent_comment.path))
.await
.unwrap();
Comment::create(pool, &child_comment_form, Some(&new_parent_comment.path)).await?;
comment_like.comment_id = new_parent_comment.id;
CommentLike::like(pool, &comment_like).await.unwrap();
let after_comment_add = PersonAggregates::read(pool, inserted_person.id)
.await
.unwrap()
.unwrap();
CommentLike::like(pool, &comment_like).await?;
let after_comment_add = PersonAggregates::read(pool, inserted_person.id).await?;
assert_eq!(2, after_comment_add.comment_count);
// TODO: fix person aggregate comment score calculation
// assert_eq!(1, after_comment_add.comment_score);
Post::delete(pool, inserted_post.id).await.unwrap();
let after_post_delete = PersonAggregates::read(pool, inserted_person.id)
.await
.unwrap()
.unwrap();
Post::delete(pool, inserted_post.id).await?;
let after_post_delete = PersonAggregates::read(pool, inserted_person.id).await?;
// TODO: fix person aggregate comment score calculation
// assert_eq!(0, after_post_delete.comment_score);
assert_eq!(0, after_post_delete.comment_count);
@ -204,24 +169,20 @@ mod tests {
assert_eq!(0, after_post_delete.post_count);
// This should delete all the associated rows, and fire triggers
let person_num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
let person_num_deleted = Person::delete(pool, inserted_person.id).await?;
assert_eq!(1, person_num_deleted);
Person::delete(pool, another_inserted_person.id)
.await
.unwrap();
Person::delete(pool, another_inserted_person.id).await?;
// Delete the community
let community_num_deleted = Community::delete(pool, inserted_community.id)
.await
.unwrap();
let community_num_deleted = Community::delete(pool, inserted_community.id).await?;
assert_eq!(1, community_num_deleted);
// Should be none found
let after_delete = PersonAggregates::read(pool, inserted_person.id)
.await
.unwrap();
assert!(after_delete.is_none());
let after_delete = PersonAggregates::read(pool, inserted_person.id).await;
assert!(after_delete.is_err());
Instance::delete(pool, inserted_instance.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
}

108
crates/db_schema/src/aggregates/post_aggregates.rs
View file

@ -49,8 +49,6 @@ impl PostAggregates {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
@ -65,26 +63,25 @@ mod tests {
traits::{Crud, Likeable},
utils::build_db_pool_for_tests,
};
use diesel::result::Error;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "thommy_community_agg");
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let another_person = PersonInsertForm::test_form(inserted_instance.id, "jerry_community_agg");
let another_inserted_person = Person::create(pool, &another_person).await.unwrap();
let another_inserted_person = Person::create(pool, &another_person).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -92,21 +89,21 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
let new_post = PostInsertForm::new(
"A test post".into(),
inserted_person.id,
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
let comment_form = CommentInsertForm::new(
inserted_person.id,
inserted_post.id,
"A test comment".into(),
);
let inserted_comment = Comment::create(pool, &comment_form, None).await.unwrap();
let inserted_comment = Comment::create(pool, &comment_form, None).await?;
let child_comment_form = CommentInsertForm::new(
inserted_person.id,
@ -114,9 +111,7 @@ mod tests {
"A test comment".into(),
);
let inserted_child_comment =
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path))
.await
.unwrap();
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path)).await?;
let post_like = PostLikeForm {
post_id: inserted_post.id,
@ -124,9 +119,9 @@ mod tests {
score: 1,
};
PostLike::like(pool, &post_like).await.unwrap();
PostLike::like(pool, &post_like).await?;
let post_aggs_before_delete = PostAggregates::read(pool, inserted_post.id).await.unwrap();
let post_aggs_before_delete = PostAggregates::read(pool, inserted_post.id).await?;
assert_eq!(2, post_aggs_before_delete.comments);
assert_eq!(1, post_aggs_before_delete.score);
@ -140,9 +135,9 @@ mod tests {
score: -1,
};
PostLike::like(pool, &post_dislike).await.unwrap();
PostLike::like(pool, &post_dislike).await?;
let post_aggs_after_dislike = PostAggregates::read(pool, inserted_post.id).await.unwrap();
let post_aggs_after_dislike = PostAggregates::read(pool, inserted_post.id).await?;
assert_eq!(2, post_aggs_after_dislike.comments);
assert_eq!(0, post_aggs_after_dislike.score);
@ -150,59 +145,51 @@ mod tests {
assert_eq!(1, post_aggs_after_dislike.downvotes);
// Remove the comments
Comment::delete(pool, inserted_comment.id).await.unwrap();
Comment::delete(pool, inserted_child_comment.id)
.await
.unwrap();
let after_comment_delete = PostAggregates::read(pool, inserted_post.id).await.unwrap();
Comment::delete(pool, inserted_comment.id).await?;
Comment::delete(pool, inserted_child_comment.id).await?;
let after_comment_delete = PostAggregates::read(pool, inserted_post.id).await?;
assert_eq!(0, after_comment_delete.comments);
assert_eq!(0, after_comment_delete.score);
assert_eq!(1, after_comment_delete.upvotes);
assert_eq!(1, after_comment_delete.downvotes);
// Remove the first post like
PostLike::remove(pool, inserted_person.id, inserted_post.id)
.await
.unwrap();
let after_like_remove = PostAggregates::read(pool, inserted_post.id).await.unwrap();
PostLike::remove(pool, inserted_person.id, inserted_post.id).await?;
let after_like_remove = PostAggregates::read(pool, inserted_post.id).await?;
assert_eq!(0, after_like_remove.comments);
assert_eq!(-1, after_like_remove.score);
assert_eq!(0, after_like_remove.upvotes);
assert_eq!(1, after_like_remove.downvotes);
// This should delete all the associated rows, and fire triggers
Person::delete(pool, another_inserted_person.id)
.await
.unwrap();
let person_num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
Person::delete(pool, another_inserted_person.id).await?;
let person_num_deleted = Person::delete(pool, inserted_person.id).await?;
assert_eq!(1, person_num_deleted);
// Delete the community
let community_num_deleted = Community::delete(pool, inserted_community.id)
.await
.unwrap();
let community_num_deleted = Community::delete(pool, inserted_community.id).await?;
assert_eq!(1, community_num_deleted);
// Should be none found, since the creator was deleted
let after_delete = PostAggregates::read(pool, inserted_post.id).await;
assert!(after_delete.is_err());
Instance::delete(pool, inserted_instance.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
#[tokio::test]
#[serial]
async fn test_soft_delete() {
async fn test_soft_delete() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "thommy_community_agg");
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -210,14 +197,14 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
let new_post = PostInsertForm::new(
"A test post".into(),
inserted_person.id,
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
let comment_form = CommentInsertForm::new(
inserted_person.id,
@ -225,9 +212,9 @@ mod tests {
"A test comment".into(),
);
let inserted_comment = Comment::create(pool, &comment_form, None).await.unwrap();
let inserted_comment = Comment::create(pool, &comment_form, None).await?;
let post_aggregates_before = PostAggregates::read(pool, inserted_post.id).await.unwrap();
let post_aggregates_before = PostAggregates::read(pool, inserted_post.id).await?;
assert_eq!(1, post_aggregates_before.comments);
Comment::update(
@ -238,10 +225,9 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let post_aggregates_after_remove = PostAggregates::read(pool, inserted_post.id).await.unwrap();
let post_aggregates_after_remove = PostAggregates::read(pool, inserted_post.id).await?;
assert_eq!(0, post_aggregates_after_remove.comments);
Comment::update(
@ -252,8 +238,7 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
Comment::update(
pool,
@ -263,10 +248,9 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let post_aggregates_after_delete = PostAggregates::read(pool, inserted_post.id).await.unwrap();
let post_aggregates_after_delete = PostAggregates::read(pool, inserted_post.id).await?;
assert_eq!(0, post_aggregates_after_delete.comments);
Comment::update(
@ -277,19 +261,17 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let post_aggregates_after_delete_remove =
PostAggregates::read(pool, inserted_post.id).await.unwrap();
let post_aggregates_after_delete_remove = PostAggregates::read(pool, inserted_post.id).await?;
assert_eq!(0, post_aggregates_after_delete_remove.comments);
Comment::delete(pool, inserted_comment.id).await.unwrap();
Post::delete(pool, inserted_post.id).await.unwrap();
Person::delete(pool, inserted_person.id).await.unwrap();
Community::delete(pool, inserted_community.id)
.await
.unwrap();
Instance::delete(pool, inserted_instance.id).await.unwrap();
Comment::delete(pool, inserted_comment.id).await?;
Post::delete(pool, inserted_post.id).await?;
Person::delete(pool, inserted_person.id).await?;
Community::delete(pool, inserted_community.id).await?;
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
}

97
crates/db_schema/src/aggregates/site_aggregates.rs
View file

@ -1,6 +1,5 @@
use crate::{
aggregates::structs::SiteAggregates,
diesel::OptionalExtension,
schema::site_aggregates,
utils::{get_conn, DbPool},
};
@ -8,15 +7,13 @@ use diesel::result::Error;
use diesel_async::RunQueryDsl;
impl SiteAggregates {
pub async fn read(pool: &mut DbPool<'_>) -> Result<Option<Self>, Error> {
pub async fn read(pool: &mut DbPool<'_>) -> Result<Self, Error> {
let conn = &mut get_conn(pool).await?;
site_aggregates::table.first(conn).await.optional()
site_aggregates::table.first(conn).await
}
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
@ -32,22 +29,21 @@ mod tests {
traits::Crud,
utils::{build_db_pool_for_tests, DbPool},
};
use diesel::result::Error;
use pretty_assertions::assert_eq;
use serial_test::serial;
async fn prepare_site_with_community(
pool: &mut DbPool<'_>,
) -> (Instance, Person, Site, Community) {
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
) -> Result<(Instance, Person, Site, Community), Error> {
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "thommy_site_agg");
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let site_form = SiteInsertForm::new("test_site".into(), inserted_instance.id);
let inserted_site = Site::create(pool, &site_form).await.unwrap();
let inserted_site = Site::create(pool, &site_form).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -56,23 +52,24 @@ mod tests {
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
(
let inserted_community = Community::create(pool, &new_community).await?;
Ok((
inserted_instance,
inserted_person,
inserted_site,
inserted_community,
)
))
}
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let (inserted_instance, inserted_person, inserted_site, inserted_community) =
prepare_site_with_community(pool).await;
prepare_site_with_community(pool).await?;
let new_post = PostInsertForm::new(
"A test post".into(),
@ -81,8 +78,8 @@ mod tests {
);
// Insert two of those posts
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let _inserted_post_again = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
let _inserted_post_again = Post::create(pool, &new_post).await?;
let comment_form = CommentInsertForm::new(
inserted_person.id,
@ -91,7 +88,7 @@ mod tests {
);
// Insert two of those comments
let inserted_comment = Comment::create(pool, &comment_form, None).await.unwrap();
let inserted_comment = Comment::create(pool, &comment_form, None).await?;
let child_comment_form = CommentInsertForm::new(
inserted_person.id,
@ -99,11 +96,9 @@ mod tests {
"A test comment".into(),
);
let _inserted_child_comment =
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path))
.await
.unwrap();
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path)).await?;
let site_aggregates_before_delete = SiteAggregates::read(pool).await.unwrap().unwrap();
let site_aggregates_before_delete = SiteAggregates::read(pool).await?;
// TODO: this is unstable, sometimes it returns 0 users, sometimes 1
//assert_eq!(0, site_aggregates_before_delete.users);
@ -112,42 +107,42 @@ mod tests {
assert_eq!(2, site_aggregates_before_delete.comments);
// Try a post delete
Post::delete(pool, inserted_post.id).await.unwrap();
let site_aggregates_after_post_delete = SiteAggregates::read(pool).await.unwrap().unwrap();
Post::delete(pool, inserted_post.id).await?;
let site_aggregates_after_post_delete = SiteAggregates::read(pool).await?;
assert_eq!(1, site_aggregates_after_post_delete.posts);
assert_eq!(0, site_aggregates_after_post_delete.comments);
// This shouuld delete all the associated rows, and fire triggers
let person_num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
let person_num_deleted = Person::delete(pool, inserted_person.id).await?;
assert_eq!(1, person_num_deleted);
// Delete the community
let community_num_deleted = Community::delete(pool, inserted_community.id)
.await
.unwrap();
let community_num_deleted = Community::delete(pool, inserted_community.id).await?;
assert_eq!(1, community_num_deleted);
// Site should still exist, it can without a site creator.
let after_delete_creator = SiteAggregates::read(pool).await;
assert!(after_delete_creator.is_ok());
Site::delete(pool, inserted_site.id).await.unwrap();
let after_delete_site = SiteAggregates::read(pool).await.unwrap();
assert!(after_delete_site.is_none());
Site::delete(pool, inserted_site.id).await?;
let after_delete_site = SiteAggregates::read(pool).await;
assert!(after_delete_site.is_err());
Instance::delete(pool, inserted_instance.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
#[tokio::test]
#[serial]
async fn test_soft_delete() {
async fn test_soft_delete() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let (inserted_instance, inserted_person, inserted_site, inserted_community) =
prepare_site_with_community(pool).await;
prepare_site_with_community(pool).await?;
let site_aggregates_before = SiteAggregates::read(pool).await.unwrap().unwrap();
let site_aggregates_before = SiteAggregates::read(pool).await?;
assert_eq!(1, site_aggregates_before.communities);
Community::update(
@ -158,10 +153,9 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let site_aggregates_after_delete = SiteAggregates::read(pool).await.unwrap().unwrap();
let site_aggregates_after_delete = SiteAggregates::read(pool).await?;
assert_eq!(0, site_aggregates_after_delete.communities);
Community::update(
@ -172,8 +166,7 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
Community::update(
pool,
@ -183,10 +176,9 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let site_aggregates_after_remove = SiteAggregates::read(pool).await.unwrap().unwrap();
let site_aggregates_after_remove = SiteAggregates::read(pool).await?;
assert_eq!(0, site_aggregates_after_remove.communities);
Community::update(
@ -197,17 +189,16 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let site_aggregates_after_remove_delete = SiteAggregates::read(pool).await.unwrap().unwrap();
let site_aggregates_after_remove_delete = SiteAggregates::read(pool).await?;
assert_eq!(0, site_aggregates_after_remove_delete.communities);
Community::delete(pool, inserted_community.id)
.await
.unwrap();
Site::delete(pool, inserted_site.id).await.unwrap();
Person::delete(pool, inserted_person.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await.unwrap();
Community::delete(pool, inserted_community.id).await?;
Site::delete(pool, inserted_site.id).await?;
Person::delete(pool, inserted_person.id).await?;
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
}

31
crates/db_schema/src/impls/activity.rs
View file

@ -58,11 +58,11 @@ impl ReceivedActivity {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use super::*;
use crate::{source::activity::ActorType, utils::build_db_pool_for_tests};
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serde_json::json;
use serial_test::serial;
@ -70,26 +70,25 @@ mod tests {
#[tokio::test]
#[serial]
async fn receive_activity_duplicate() {
async fn receive_activity_duplicate() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let ap_id: DbUrl = Url::parse("http://example.com/activity/531")
.unwrap()
.into();
let ap_id: DbUrl = Url::parse("http://example.com/activity/531")?.into();
// inserting activity should only work once
ReceivedActivity::create(pool, &ap_id).await.unwrap();
ReceivedActivity::create(pool, &ap_id).await.unwrap_err();
ReceivedActivity::create(pool, &ap_id).await?;
let second = ReceivedActivity::create(pool, &ap_id).await;
assert!(second.is_err());
Ok(())
}
#[tokio::test]
#[serial]
async fn sent_activity_write_read() {
async fn sent_activity_write_read() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let ap_id: DbUrl = Url::parse("http://example.com/activity/412")
.unwrap()
.into();
let ap_id: DbUrl = Url::parse("http://example.com/activity/412")?.into();
let data = json!({
"key1": "0xF9BA143B95FF6D82",
"key2": "42",
@ -100,20 +99,20 @@ mod tests {
ap_id: ap_id.clone(),
data: data.clone(),
sensitive,
actor_apub_id: Url::parse("http://example.com/u/exampleuser")
.unwrap()
.into(),
actor_apub_id: Url::parse("http://example.com/u/exampleuser")?.into(),
actor_type: ActorType::Person,
send_all_instances: false,
send_community_followers_of: None,
send_inboxes: vec![],
};
SentActivity::create(pool, form).await.unwrap();
SentActivity::create(pool, form).await?;
let res = SentActivity::read_from_apub_id(pool, &ap_id).await.unwrap();
let res = SentActivity::read_from_apub_id(pool, &ap_id).await?;
assert_eq!(res.ap_id, ap_id);
assert_eq!(res.data, data);
assert_eq!(res.sensitive, sensitive);
Ok(())
}
}

266
crates/db_schema/src/impls/actor_language.rs
View file

@ -199,13 +199,12 @@ impl CommunityLanguage {
/// Returns true if the given language is one of configured languages for given community
pub async fn is_allowed_community_language(
pool: &mut DbPool<'_>,
for_language_id: Option<LanguageId>,
for_language_id: LanguageId,
for_community_id: CommunityId,
) -> LemmyResult<()> {
use crate::schema::community_language::dsl::community_language;
let conn = &mut get_conn(pool).await?;
if let Some(for_language_id) = for_language_id {
let is_allowed = select(exists(
community_language.find((for_community_id, for_language_id)),
))
@ -217,9 +216,6 @@ impl CommunityLanguage {
} else {
Err(LemmyErrorType::LanguageNotAllowed)?
}
} else {
Ok(())
}
}
/// When site languages are updated, delete all languages of local communities which are not
@ -327,7 +323,7 @@ pub async fn default_post_language(
pool: &mut DbPool<'_>,
community_id: CommunityId,
local_user_id: LocalUserId,
) -> Result<Option<LanguageId>, Error> {
) -> Result<LanguageId, Error> {
use crate::schema::{community_language::dsl as cl, local_user_language::dsl as ul};
let conn = &mut get_conn(pool).await?;
let mut intersection = ul::local_user_language
@ -339,12 +335,12 @@ pub async fn default_post_language(
.await?;
if intersection.len() == 1 {
Ok(intersection.pop())
Ok(intersection.pop().unwrap_or(UNDETERMINED_ID))
} else if intersection.len() == 2 && intersection.contains(&UNDETERMINED_ID) {
intersection.retain(|i| i != &UNDETERMINED_ID);
Ok(intersection.pop())
Ok(intersection.pop().unwrap_or(UNDETERMINED_ID))
} else {
Ok(None)
Ok(UNDETERMINED_ID)
}
}
@ -392,7 +388,6 @@ async fn convert_read_languages(
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
#[expect(clippy::indexing_slicing)]
mod tests {
@ -409,168 +404,148 @@ mod tests {
traits::Crud,
utils::build_db_pool_for_tests,
};
use diesel::result::Error;
use pretty_assertions::assert_eq;
use serial_test::serial;
async fn test_langs1(pool: &mut DbPool<'_>) -> Vec<LanguageId> {
vec![
Language::read_id_from_code(pool, Some("en"))
.await
.unwrap()
.unwrap(),
Language::read_id_from_code(pool, Some("fr"))
.await
.unwrap()
.unwrap(),
Language::read_id_from_code(pool, Some("ru"))
.await
.unwrap()
.unwrap(),
]
async fn test_langs1(pool: &mut DbPool<'_>) -> Result<Vec<LanguageId>, Error> {
Ok(vec![
Language::read_id_from_code(pool, "en").await?,
Language::read_id_from_code(pool, "fr").await?,
Language::read_id_from_code(pool, "ru").await?,
])
}
async fn test_langs2(pool: &mut DbPool<'_>) -> Vec<LanguageId> {
vec![
Language::read_id_from_code(pool, Some("fi"))
.await
.unwrap()
.unwrap(),
Language::read_id_from_code(pool, Some("se"))
.await
.unwrap()
.unwrap(),
]
async fn test_langs2(pool: &mut DbPool<'_>) -> Result<Vec<LanguageId>, Error> {
Ok(vec![
Language::read_id_from_code(pool, "fi").await?,
Language::read_id_from_code(pool, "se").await?,
])
}
async fn create_test_site(pool: &mut DbPool<'_>) -> (Site, Instance) {
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
async fn create_test_site(pool: &mut DbPool<'_>) -> Result<(Site, Instance), Error> {
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let site_form = SiteInsertForm::new("test site".to_string(), inserted_instance.id);
let site = Site::create(pool, &site_form).await.unwrap();
let site = Site::create(pool, &site_form).await?;
// Create a local site, since this is necessary for local languages
let local_site_form = LocalSiteInsertForm::new(site.id);
LocalSite::create(pool, &local_site_form).await.unwrap();
LocalSite::create(pool, &local_site_form).await?;
(site, inserted_instance)
Ok((site, inserted_instance))
}
#[tokio::test]
#[serial]
async fn test_convert_update_languages() {
async fn test_convert_update_languages() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
// call with empty vec, returns all languages
let conn = &mut get_conn(pool).await.unwrap();
let converted1 = convert_update_languages(conn, vec![]).await.unwrap();
let conn = &mut get_conn(pool).await?;
let converted1 = convert_update_languages(conn, vec![]).await?;
assert_eq!(184, converted1.len());
// call with nonempty vec, returns same vec
let test_langs = test_langs1(&mut conn.into()).await;
let converted2 = convert_update_languages(conn, test_langs.clone())
.await
.unwrap();
let test_langs = test_langs1(&mut conn.into()).await?;
let converted2 = convert_update_languages(conn, test_langs.clone()).await?;
assert_eq!(test_langs, converted2);
Ok(())
}
#[tokio::test]
#[serial]
async fn test_convert_read_languages() {
async fn test_convert_read_languages() -> Result<(), Error> {
use crate::schema::language::dsl::{id, language};
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
// call with all languages, returns empty vec
let conn = &mut get_conn(pool).await.unwrap();
let all_langs = language.select(id).get_results(conn).await.unwrap();
let converted1: Vec<LanguageId> = convert_read_languages(conn, all_langs).await.unwrap();
let conn = &mut get_conn(pool).await?;
let all_langs = language.select(id).get_results(conn).await?;
let converted1: Vec<LanguageId> = convert_read_languages(conn, all_langs).await?;
assert_eq!(0, converted1.len());
// call with nonempty vec, returns same vec
let test_langs = test_langs1(&mut conn.into()).await;
let converted2 = convert_read_languages(conn, test_langs.clone())
.await
.unwrap();
let test_langs = test_langs1(&mut conn.into()).await?;
let converted2 = convert_read_languages(conn, test_langs.clone()).await?;
assert_eq!(test_langs, converted2);
Ok(())
}
#[tokio::test]
#[serial]
async fn test_site_languages() {
async fn test_site_languages() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let (site, instance) = create_test_site(pool).await;
let site_languages1 = SiteLanguage::read_local_raw(pool).await.unwrap();
let (site, instance) = create_test_site(pool).await?;
let site_languages1 = SiteLanguage::read_local_raw(pool).await?;
// site is created with all languages
assert_eq!(184, site_languages1.len());
let test_langs = test_langs1(pool).await;
SiteLanguage::update(pool, test_langs.clone(), &site)
.await
.unwrap();
let test_langs = test_langs1(pool).await?;
SiteLanguage::update(pool, test_langs.clone(), &site).await?;
let site_languages2 = SiteLanguage::read_local_raw(pool).await.unwrap();
let site_languages2 = SiteLanguage::read_local_raw(pool).await?;
// after update, site only has new languages
assert_eq!(test_langs, site_languages2);
Site::delete(pool, site.id).await.unwrap();
Instance::delete(pool, instance.id).await.unwrap();
LocalSite::delete(pool).await.unwrap();
Site::delete(pool, site.id).await?;
Instance::delete(pool, instance.id).await?;
LocalSite::delete(pool).await?;
Ok(())
}
#[tokio::test]
#[serial]
async fn test_user_languages() {
async fn test_user_languages() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let (site, instance) = create_test_site(pool).await;
let (site, instance) = create_test_site(pool).await?;
let person_form = PersonInsertForm::test_form(instance.id, "my test person");
let person = Person::create(pool, &person_form).await.unwrap();
let person = Person::create(pool, &person_form).await?;
let local_user_form = LocalUserInsertForm::test_form(person.id);
let local_user = LocalUser::create(pool, &local_user_form, vec![])
.await
.unwrap();
let local_user_langs1 = LocalUserLanguage::read(pool, local_user.id).await.unwrap();
let local_user = LocalUser::create(pool, &local_user_form, vec![]).await?;
let local_user_langs1 = LocalUserLanguage::read(pool, local_user.id).await?;
// new user should be initialized with all languages
assert_eq!(0, local_user_langs1.len());
// update user languages
let test_langs2 = test_langs2(pool).await;
LocalUserLanguage::update(pool, test_langs2, local_user.id)
.await
.unwrap();
let local_user_langs2 = LocalUserLanguage::read(pool, local_user.id).await.unwrap();
let test_langs2 = test_langs2(pool).await?;
LocalUserLanguage::update(pool, test_langs2, local_user.id).await?;
let local_user_langs2 = LocalUserLanguage::read(pool, local_user.id).await?;
assert_eq!(3, local_user_langs2.len());
Person::delete(pool, person.id).await.unwrap();
LocalUser::delete(pool, local_user.id).await.unwrap();
Site::delete(pool, site.id).await.unwrap();
LocalSite::delete(pool).await.unwrap();
Instance::delete(pool, instance.id).await.unwrap();
Person::delete(pool, person.id).await?;
LocalUser::delete(pool, local_user.id).await?;
Site::delete(pool, site.id).await?;
LocalSite::delete(pool).await?;
Instance::delete(pool, instance.id).await?;
Ok(())
}
#[tokio::test]
#[serial]
async fn test_community_languages() {
async fn test_community_languages() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let (site, instance) = create_test_site(pool).await;
let test_langs = test_langs1(pool).await;
SiteLanguage::update(pool, test_langs.clone(), &site)
.await
.unwrap();
let (site, instance) = create_test_site(pool).await?;
let test_langs = test_langs1(pool).await?;
SiteLanguage::update(pool, test_langs.clone(), &site).await?;
let read_site_langs = SiteLanguage::read(pool, site.id).await.unwrap();
let read_site_langs = SiteLanguage::read(pool, site.id).await?;
assert_eq!(test_langs, read_site_langs);
// Test the local ones are the same
let read_local_site_langs = SiteLanguage::read_local_raw(pool).await.unwrap();
let read_local_site_langs = SiteLanguage::read_local_raw(pool).await?;
assert_eq!(test_langs, read_local_site_langs);
let community_form = CommunityInsertForm::new(
@ -579,52 +554,48 @@ mod tests {
"test community".to_string(),
"pubkey".to_string(),
);
let community = Community::create(pool, &community_form).await.unwrap();
let community_langs1 = CommunityLanguage::read(pool, community.id).await.unwrap();
let community = Community::create(pool, &community_form).await?;
let community_langs1 = CommunityLanguage::read(pool, community.id).await?;
// community is initialized with site languages
assert_eq!(test_langs, community_langs1);
let allowed_lang1 =
CommunityLanguage::is_allowed_community_language(pool, Some(test_langs[0]), community.id)
.await;
CommunityLanguage::is_allowed_community_language(pool, test_langs[0], community.id).await;
assert!(allowed_lang1.is_ok());
let test_langs2 = test_langs2(pool).await;
let test_langs2 = test_langs2(pool).await?;
let allowed_lang2 =
CommunityLanguage::is_allowed_community_language(pool, Some(test_langs2[0]), community.id)
.await;
CommunityLanguage::is_allowed_community_language(pool, test_langs2[0], community.id).await;
assert!(allowed_lang2.is_err());
// limit site languages to en, fi. after this, community languages should be updated to
// intersection of old languages (en, fr, ru) and (en, fi), which is only fi.
SiteLanguage::update(pool, vec![test_langs[0], test_langs2[0]], &site)
.await
.unwrap();
let community_langs2 = CommunityLanguage::read(pool, community.id).await.unwrap();
SiteLanguage::update(pool, vec![test_langs[0], test_langs2[0]], &site).await?;
let community_langs2 = CommunityLanguage::read(pool, community.id).await?;
assert_eq!(vec![test_langs[0]], community_langs2);
// update community languages to different ones
CommunityLanguage::update(pool, test_langs2.clone(), community.id)
.await
.unwrap();
let community_langs3 = CommunityLanguage::read(pool, community.id).await.unwrap();
CommunityLanguage::update(pool, test_langs2.clone(), community.id).await?;
let community_langs3 = CommunityLanguage::read(pool, community.id).await?;
assert_eq!(test_langs2, community_langs3);
Community::delete(pool, community.id).await.unwrap();
Site::delete(pool, site.id).await.unwrap();
LocalSite::delete(pool).await.unwrap();
Instance::delete(pool, instance.id).await.unwrap();
Community::delete(pool, community.id).await?;
Site::delete(pool, site.id).await?;
LocalSite::delete(pool).await?;
Instance::delete(pool, instance.id).await?;
Ok(())
}
#[tokio::test]
#[serial]
async fn test_default_post_language() {
async fn test_default_post_language() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let (site, instance) = create_test_site(pool).await;
let test_langs = test_langs1(pool).await;
let test_langs2 = test_langs2(pool).await;
let (site, instance) = create_test_site(pool).await?;
let test_langs = test_langs1(pool).await?;
let test_langs2 = test_langs2(pool).await?;
let community_form = CommunityInsertForm::new(
instance.id,
@ -632,58 +603,39 @@ mod tests {
"test community".to_string(),
"pubkey".to_string(),
);
let community = Community::create(pool, &community_form).await.unwrap();
CommunityLanguage::update(pool, test_langs, community.id)
.await
.unwrap();
let community = Community::create(pool, &community_form).await?;
CommunityLanguage::update(pool, test_langs, community.id).await?;
let person_form = PersonInsertForm::test_form(instance.id, "my test person");
let person = Person::create(pool, &person_form).await.unwrap();
let person = Person::create(pool, &person_form).await?;
let local_user_form = LocalUserInsertForm::test_form(person.id);
let local_user = LocalUser::create(pool, &local_user_form, vec![])
.await
.unwrap();
LocalUserLanguage::update(pool, test_langs2, local_user.id)
.await
.unwrap();
let local_user = LocalUser::create(pool, &local_user_form, vec![]).await?;
LocalUserLanguage::update(pool, test_langs2, local_user.id).await?;
// no overlap in user/community languages, so defaults to undetermined
let def1 = default_post_language(pool, community.id, local_user.id)
.await
.unwrap();
assert_eq!(None, def1);
let def1 = default_post_language(pool, community.id, local_user.id).await?;
assert_eq!(UNDETERMINED_ID, def1);
let ru = Language::read_id_from_code(pool, Some("ru"))
.await
.unwrap()
.unwrap();
let ru = Language::read_id_from_code(pool, "ru").await?;
let test_langs3 = vec![
ru,
Language::read_id_from_code(pool, Some("fi"))
.await
.unwrap()
.unwrap(),
Language::read_id_from_code(pool, Some("se"))
.await
.unwrap()
.unwrap(),
Language::read_id_from_code(pool, "fi").await?,
Language::read_id_from_code(pool, "se").await?,
UNDETERMINED_ID,
];
LocalUserLanguage::update(pool, test_langs3, local_user.id)
.await
.unwrap();
LocalUserLanguage::update(pool, test_langs3, local_user.id).await?;
// this time, both have ru as common lang
let def2 = default_post_language(pool, community.id, local_user.id)
.await
.unwrap();
assert_eq!(Some(ru), def2);
let def2 = default_post_language(pool, community.id, local_user.id).await?;
assert_eq!(ru, def2);
Person::delete(pool, person.id).await.unwrap();
Community::delete(pool, community.id).await.unwrap();
LocalUser::delete(pool, local_user.id).await.unwrap();
Site::delete(pool, site.id).await.unwrap();
LocalSite::delete(pool).await.unwrap();
Instance::delete(pool, instance.id).await.unwrap();
Person::delete(pool, person.id).await?;
Community::delete(pool, community.id).await?;
LocalUser::delete(pool, local_user.id).await?;
Site::delete(pool, site.id).await?;
LocalSite::delete(pool).await?;
Instance::delete(pool, instance.id).await?;
Ok(())
}
}

59
crates/db_schema/src/impls/comment.rs
View file

@ -196,7 +196,6 @@ impl Saveable for CommentSaved {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
@ -220,23 +219,22 @@ mod tests {
utils::build_db_pool_for_tests,
};
use diesel_ltree::Ltree;
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
use url::Url;
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "terry");
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -244,21 +242,21 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
let new_post = PostInsertForm::new(
"A test post".into(),
inserted_person.id,
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
let comment_form = CommentInsertForm::new(
inserted_person.id,
inserted_post.id,
"A test comment".into(),
);
let inserted_comment = Comment::create(pool, &comment_form, None).await.unwrap();
let inserted_comment = Comment::create(pool, &comment_form, None).await?;
let expected_comment = Comment {
id: inserted_comment.id,
@ -273,8 +271,7 @@ mod tests {
ap_id: Url::parse(&format!(
"https://lemmy-alpha/comment/{}",
inserted_comment.id
))
.unwrap()
))?
.into(),
distinguished: false,
local: true,
@ -287,9 +284,7 @@ mod tests {
"A child comment".into(),
);
let inserted_child_comment =
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path))
.await
.unwrap();
Comment::create(pool, &child_comment_form, Some(&inserted_comment.path)).await?;
// Comment Like
let comment_like_form = CommentLikeForm {
@ -299,7 +294,7 @@ mod tests {
score: 1,
};
let inserted_comment_like = CommentLike::like(pool, &comment_like_form).await.unwrap();
let inserted_comment_like = CommentLike::like(pool, &comment_like_form).await?;
let expected_comment_like = CommentLike {
comment_id: inserted_comment.id,
@ -315,7 +310,7 @@ mod tests {
person_id: inserted_person.id,
};
let inserted_comment_saved = CommentSaved::save(pool, &comment_saved_form).await.unwrap();
let inserted_comment_saved = CommentSaved::save(pool, &comment_saved_form).await?;
let expected_comment_saved = CommentSaved {
comment_id: inserted_comment.id,
@ -328,27 +323,17 @@ mod tests {
..Default::default()
};
let updated_comment = Comment::update(pool, inserted_comment.id, &comment_update_form)
.await
.unwrap();
let updated_comment = Comment::update(pool, inserted_comment.id, &comment_update_form).await?;
let read_comment = Comment::read(pool, inserted_comment.id).await.unwrap();
let like_removed = CommentLike::remove(pool, inserted_person.id, inserted_comment.id)
.await
.unwrap();
let saved_removed = CommentSaved::unsave(pool, &comment_saved_form)
.await
.unwrap();
let num_deleted = Comment::delete(pool, inserted_comment.id).await.unwrap();
Comment::delete(pool, inserted_child_comment.id)
.await
.unwrap();
Post::delete(pool, inserted_post.id).await.unwrap();
Community::delete(pool, inserted_community.id)
.await
.unwrap();
Person::delete(pool, inserted_person.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await.unwrap();
let read_comment = Comment::read(pool, inserted_comment.id).await?;
let like_removed = CommentLike::remove(pool, inserted_person.id, inserted_comment.id).await?;
let saved_removed = CommentSaved::unsave(pool, &comment_saved_form).await?;
let num_deleted = Comment::delete(pool, inserted_comment.id).await?;
Comment::delete(pool, inserted_child_comment.id).await?;
Post::delete(pool, inserted_post.id).await?;
Community::delete(pool, inserted_community.id).await?;
Person::delete(pool, inserted_person.id).await?;
Instance::delete(pool, inserted_instance.id).await?;
assert_eq!(expected_comment, read_comment);
assert_eq!(expected_comment, inserted_comment);
@ -362,5 +347,7 @@ mod tests {
assert_eq!(1, like_removed);
assert_eq!(1, saved_removed);
assert_eq!(1, num_deleted);
Ok(())
}
}

18
crates/db_schema/src/impls/federation_allowlist.rs
View file

@ -48,19 +48,19 @@ impl FederationAllowList {
}
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
source::{federation_allowlist::FederationAllowList, instance::Instance},
utils::build_db_pool_for_tests,
};
use diesel::result::Error;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_allowlist_insert_and_clear() {
async fn test_allowlist_insert_and_clear() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let domains = vec![
@ -71,9 +71,9 @@ mod tests {
let allowed = Some(domains.clone());
FederationAllowList::replace(pool, allowed).await.unwrap();
FederationAllowList::replace(pool, allowed).await?;
let allows = Instance::allowlist(pool).await.unwrap();
let allows = Instance::allowlist(pool).await?;
let allows_domains = allows
.iter()
.map(|i| i.domain.clone())
@ -85,13 +85,13 @@ mod tests {
// Now test clearing them via Some(empty vec)
let clear_allows = Some(Vec::new());
FederationAllowList::replace(pool, clear_allows)
.await
.unwrap();
let allows = Instance::allowlist(pool).await.unwrap();
FederationAllowList::replace(pool, clear_allows).await?;
let allows = Instance::allowlist(pool).await?;
assert_eq!(0, allows.len());
Instance::delete_all(pool).await.unwrap();
Instance::delete_all(pool).await?;
Ok(())
}
}

30
crates/db_schema/src/impls/language.rs
View file

@ -1,3 +1,4 @@
use super::actor_language::UNDETERMINED_ID;
use crate::{
diesel::ExpressionMethods,
newtypes::LanguageId,
@ -19,47 +20,42 @@ impl Language {
language::table.find(id_).first(conn).await
}
/// Attempts to find the given language code and return its ID. If not found, returns none.
pub async fn read_id_from_code(
pool: &mut DbPool<'_>,
code_: Option<&str>,
) -> Result<Option<LanguageId>, Error> {
if let Some(code_) = code_ {
/// Attempts to find the given language code and return its ID.
pub async fn read_id_from_code(pool: &mut DbPool<'_>, code_: &str) -> Result<LanguageId, Error> {
let conn = &mut get_conn(pool).await?;
Ok(
language::table
let res = language::table
.filter(language::code.eq(code_))
.first::<Self>(conn)
.await
.map(|l| l.id)
.ok(),
)
} else {
Ok(None)
}
.map(|l| l.id);
// Return undetermined by default
Ok(res.unwrap_or(UNDETERMINED_ID))
}
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
#[expect(clippy::indexing_slicing)]
mod tests {
use crate::{source::language::Language, utils::build_db_pool_for_tests};
use diesel::result::Error;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_languages() {
async fn test_languages() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let all = Language::read_all(pool).await.unwrap();
let all = Language::read_all(pool).await?;
assert_eq!(184, all.len());
assert_eq!("ak", all[5].code);
assert_eq!("lv", all[99].code);
assert_eq!("yi", all[179].code);
Ok(())
}
}

66
crates/db_schema/src/impls/post.rs
View file

@ -392,7 +392,6 @@ impl PostHide {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
@ -415,6 +414,7 @@ mod tests {
utils::build_db_pool_for_tests,
};
use chrono::DateTime;
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
use std::collections::HashSet;
@ -422,17 +422,15 @@ mod tests {
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "jim");
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -441,27 +439,27 @@ mod tests {
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
let new_post = PostInsertForm::new(
"A test post".into(),
inserted_person.id,
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
let new_post2 = PostInsertForm::new(
"A test post 2".into(),
inserted_person.id,
inserted_community.id,
);
let inserted_post2 = Post::create(pool, &new_post2).await.unwrap();
let inserted_post2 = Post::create(pool, &new_post2).await?;
let new_scheduled_post = PostInsertForm {
scheduled_publish_time: Some(DateTime::from_timestamp_nanos(i64::MAX)),
..PostInsertForm::new("beans".into(), inserted_person.id, inserted_community.id)
};
let inserted_scheduled_post = Post::create(pool, &new_scheduled_post).await.unwrap();
let inserted_scheduled_post = Post::create(pool, &new_scheduled_post).await?;
let expected_post = Post {
id: inserted_post.id,
@ -481,9 +479,7 @@ mod tests {
embed_description: None,
embed_video_url: None,
thumbnail_url: None,
ap_id: Url::parse(&format!("https://lemmy-alpha/post/{}", inserted_post.id))
.unwrap()
.into(),
ap_id: Url::parse(&format!("https://lemmy-alpha/post/{}", inserted_post.id))?.into(),
local: true,
language_id: Default::default(),
featured_community: false,
@ -499,7 +495,7 @@ mod tests {
score: 1,
};
let inserted_post_like = PostLike::like(pool, &post_like_form).await.unwrap();
let inserted_post_like = PostLike::like(pool, &post_like_form).await?;
let expected_post_like = PostLike {
post_id: inserted_post.id,
@ -514,7 +510,7 @@ mod tests {
person_id: inserted_person.id,
};
let inserted_post_saved = PostSaved::save(pool, &post_saved_form).await.unwrap();
let inserted_post_saved = PostSaved::save(pool, &post_saved_form).await?;
let expected_post_saved = PostSaved {
post_id: inserted_post.id,
@ -528,57 +524,47 @@ mod tests {
HashSet::from([inserted_post.id, inserted_post2.id]),
inserted_person.id,
)
.await
.unwrap();
.await?;
assert_eq!(2, marked_as_read);
let read_post = Post::read(pool, inserted_post.id).await.unwrap();
let read_post = Post::read(pool, inserted_post.id).await?;
let new_post_update = PostUpdateForm {
name: Some("A test post".into()),
..Default::default()
};
let updated_post = Post::update(pool, inserted_post.id, &new_post_update)
.await
.unwrap();
let updated_post = Post::update(pool, inserted_post.id, &new_post_update).await?;
// Scheduled post count
let scheduled_post_count = Post::user_scheduled_post_count(inserted_person.id, pool)
.await
.unwrap();
let scheduled_post_count = Post::user_scheduled_post_count(inserted_person.id, pool).await?;
assert_eq!(1, scheduled_post_count);
let like_removed = PostLike::remove(pool, inserted_person.id, inserted_post.id)
.await
.unwrap();
let like_removed = PostLike::remove(pool, inserted_person.id, inserted_post.id).await?;
assert_eq!(1, like_removed);
let saved_removed = PostSaved::unsave(pool, &post_saved_form).await.unwrap();
let saved_removed = PostSaved::unsave(pool, &post_saved_form).await?;
assert_eq!(1, saved_removed);
let read_removed = PostRead::mark_as_unread(
pool,
HashSet::from([inserted_post.id, inserted_post2.id]),
inserted_person.id,
)
.await
.unwrap();
.await?;
assert_eq!(2, read_removed);
let num_deleted = Post::delete(pool, inserted_post.id).await.unwrap()
+ Post::delete(pool, inserted_post2.id).await.unwrap()
+ Post::delete(pool, inserted_scheduled_post.id)
.await
.unwrap();
let num_deleted = Post::delete(pool, inserted_post.id).await?
+ Post::delete(pool, inserted_post2.id).await?
+ Post::delete(pool, inserted_scheduled_post.id).await?;
assert_eq!(3, num_deleted);
Community::delete(pool, inserted_community.id)
.await
.unwrap();
Person::delete(pool, inserted_person.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await.unwrap();
Community::delete(pool, inserted_community.id).await?;
Person::delete(pool, inserted_person.id).await?;
Instance::delete(pool, inserted_instance.id).await?;
assert_eq!(expected_post, read_post);
assert_eq!(expected_post, inserted_post);
assert_eq!(expected_post, updated_post);
assert_eq!(expected_post_like, inserted_post_like);
assert_eq!(expected_post_saved, inserted_post_saved);
Ok(())
}
}

52
crates/db_schema/src/impls/post_report.rs
View file

@ -80,7 +80,6 @@ impl Reportable for PostReport {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use super::*;
@ -94,14 +93,13 @@ mod tests {
traits::Crud,
utils::build_db_pool_for_tests,
};
use diesel::result::Error;
use serial_test::serial;
async fn init(pool: &mut DbPool<'_>) -> (Person, PostReport) {
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
async fn init(pool: &mut DbPool<'_>) -> Result<(Person, PostReport), Error> {
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let person_form = PersonInsertForm::test_form(inserted_instance.id, "jim");
let person = Person::create(pool, &person_form).await.unwrap();
let person = Person::create(pool, &person_form).await?;
let community_form = CommunityInsertForm::new(
inserted_instance.id,
@ -109,10 +107,10 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let community = Community::create(pool, &community_form).await.unwrap();
let community = Community::create(pool, &community_form).await?;
let form = PostInsertForm::new("A test post".into(), person.id, community.id);
let post = Post::create(pool, &form).await.unwrap();
let post = Post::create(pool, &form).await?;
let report_form = PostReportForm {
post_id: post.id,
@ -120,46 +118,46 @@ mod tests {
reason: "my reason".to_string(),
..Default::default()
};
let report = PostReport::report(pool, &report_form).await.unwrap();
(person, report)
let report = PostReport::report(pool, &report_form).await?;
Ok((person, report))
}
#[tokio::test]
#[serial]
async fn test_resolve_post_report() {
async fn test_resolve_post_report() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let (person, report) = init(pool).await;
let (person, report) = init(pool).await?;
let resolved_count = PostReport::resolve(pool, report.id, person.id)
.await
.unwrap();
let resolved_count = PostReport::resolve(pool, report.id, person.id).await?;
assert_eq!(resolved_count, 1);
let unresolved_count = PostReport::unresolve(pool, report.id, person.id)
.await
.unwrap();
let unresolved_count = PostReport::unresolve(pool, report.id, person.id).await?;
assert_eq!(unresolved_count, 1);
Person::delete(pool, person.id).await.unwrap();
Post::delete(pool, report.post_id).await.unwrap();
Person::delete(pool, person.id).await?;
Post::delete(pool, report.post_id).await?;
Ok(())
}
#[tokio::test]
#[serial]
async fn test_resolve_all_post_reports() {
async fn test_resolve_all_post_reports() -> Result<(), Error> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let (person, report) = init(pool).await;
let (person, report) = init(pool).await?;
let resolved_count = PostReport::resolve_all_for_object(pool, report.post_id, person.id)
.await
.unwrap();
let resolved_count =
PostReport::resolve_all_for_object(pool, report.post_id, person.id).await?;
assert_eq!(resolved_count, 1);
Person::delete(pool, person.id).await.unwrap();
Post::delete(pool, report.post_id).await.unwrap();
Person::delete(pool, person.id).await?;
Post::delete(pool, report.post_id).await?;
Ok(())
}
}

40
crates/db_schema/src/impls/private_message.rs
View file

@ -85,7 +85,6 @@ impl PrivateMessage {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
@ -97,27 +96,26 @@ mod tests {
traits::Crud,
utils::build_db_pool_for_tests,
};
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
use url::Url;
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let creator_form = PersonInsertForm::test_form(inserted_instance.id, "creator_pm");
let inserted_creator = Person::create(pool, &creator_form).await.unwrap();
let inserted_creator = Person::create(pool, &creator_form).await?;
let recipient_form = PersonInsertForm::test_form(inserted_instance.id, "recipient_pm");
let inserted_recipient = Person::create(pool, &recipient_form).await.unwrap();
let inserted_recipient = Person::create(pool, &recipient_form).await?;
let private_message_form = PrivateMessageInsertForm::new(
inserted_creator.id,
@ -125,9 +123,7 @@ mod tests {
"A test private message".into(),
);
let inserted_private_message = PrivateMessage::create(pool, &private_message_form)
.await
.unwrap();
let inserted_private_message = PrivateMessage::create(pool, &private_message_form).await?;
let expected_private_message = PrivateMessage {
id: inserted_private_message.id,
@ -141,15 +137,12 @@ mod tests {
ap_id: Url::parse(&format!(
"https://lemmy-alpha/private_message/{}",
inserted_private_message.id
))
.unwrap()
))?
.into(),
local: true,
};
let read_private_message = PrivateMessage::read(pool, inserted_private_message.id)
.await
.unwrap();
let read_private_message = PrivateMessage::read(pool, inserted_private_message.id).await?;
let private_message_update_form = PrivateMessageUpdateForm {
content: Some("A test private message".into()),
@ -160,8 +153,7 @@ mod tests {
inserted_private_message.id,
&private_message_update_form,
)
.await
.unwrap();
.await?;
let deleted_private_message = PrivateMessage::update(
pool,
@ -171,8 +163,7 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let marked_read_private_message = PrivateMessage::update(
pool,
inserted_private_message.id,
@ -181,16 +172,17 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
Person::delete(pool, inserted_creator.id).await.unwrap();
Person::delete(pool, inserted_recipient.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await.unwrap();
.await?;
Person::delete(pool, inserted_creator.id).await?;
Person::delete(pool, inserted_recipient.id).await?;
Instance::delete(pool, inserted_instance.id).await?;
assert_eq!(expected_private_message, read_private_message);
assert_eq!(expected_private_message, updated_private_message);
assert_eq!(expected_private_message, inserted_private_message);
assert!(deleted_private_message.deleted);
assert!(marked_read_private_message.read);
Ok(())
}
}

7
crates/db_schema/src/impls/secret.rs
View file

@ -1,5 +1,4 @@
use crate::{
diesel::OptionalExtension,
schema::secret::dsl::secret,
source::secret::Secret,
utils::{get_conn, DbPool},
@ -10,12 +9,12 @@ use diesel_async::RunQueryDsl;
impl Secret {
/// Initialize the Secrets from the DB.
/// Warning: You should only call this once.
pub async fn init(pool: &mut DbPool<'_>) -> Result<Option<Secret>, Error> {
pub async fn init(pool: &mut DbPool<'_>) -> Result<Secret, Error> {
Self::read_secrets(pool).await
}
async fn read_secrets(pool: &mut DbPool<'_>) -> Result<Option<Self>, Error> {
async fn read_secrets(pool: &mut DbPool<'_>) -> Result<Self, Error> {
let conn = &mut get_conn(pool).await?;
secret.first(conn).await.optional()
secret.first(conn).await
}
}

81
crates/db_views/src/comment_report_view.rs
View file

@ -259,7 +259,6 @@ impl CommentReportQuery {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
#[expect(clippy::indexing_slicing)]
mod tests {
@ -284,27 +283,24 @@ mod tests {
CommunityVisibility,
SubscribedType,
};
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "timmy_crv");
let inserted_timmy = Person::create(pool, &new_person).await.unwrap();
let inserted_timmy = Person::create(pool, &new_person).await?;
let new_local_user = LocalUserInsertForm::test_form(inserted_timmy.id);
let timmy_local_user = LocalUser::create(pool, &new_local_user, vec![])
.await
.unwrap();
let timmy_local_user = LocalUser::create(pool, &new_local_user, vec![]).await?;
let timmy_view = LocalUserView {
local_user: timmy_local_user,
local_user_vote_display_mode: LocalUserVoteDisplayMode::default(),
@ -314,12 +310,12 @@ mod tests {
let new_person_2 = PersonInsertForm::test_form(inserted_instance.id, "sara_crv");
let inserted_sara = Person::create(pool, &new_person_2).await.unwrap();
let inserted_sara = Person::create(pool, &new_person_2).await?;
// Add a third person, since new ppl can only report something once.
let new_person_3 = PersonInsertForm::test_form(inserted_instance.id, "jessica_crv");
let inserted_jessica = Person::create(pool, &new_person_3).await.unwrap();
let inserted_jessica = Person::create(pool, &new_person_3).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -327,7 +323,7 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
// Make timmy a mod
let timmy_moderator_form = CommunityModeratorForm {
@ -335,9 +331,7 @@ mod tests {
person_id: inserted_timmy.id,
};
let _inserted_moderator = CommunityModerator::join(pool, &timmy_moderator_form)
.await
.unwrap();
let _inserted_moderator = CommunityModerator::join(pool, &timmy_moderator_form).await?;
let new_post = PostInsertForm::new(
"A test post crv".into(),
@ -345,14 +339,14 @@ mod tests {
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
let comment_form = CommentInsertForm::new(
inserted_timmy.id,
inserted_post.id,
"A test comment 32".into(),
);
let inserted_comment = Comment::create(pool, &comment_form, None).await.unwrap();
let inserted_comment = Comment::create(pool, &comment_form, None).await?;
// sara reports
let sara_report_form = CommentReportForm {
@ -362,9 +356,7 @@ mod tests {
reason: "from sara".into(),
};
let inserted_sara_report = CommentReport::report(pool, &sara_report_form)
.await
.unwrap();
let inserted_sara_report = CommentReport::report(pool, &sara_report_form).await?;
// jessica reports
let jessica_report_form = CommentReportForm {
@ -374,18 +366,12 @@ mod tests {
reason: "from jessica".into(),
};
let inserted_jessica_report = CommentReport::report(pool, &jessica_report_form)
.await
.unwrap();
let inserted_jessica_report = CommentReport::report(pool, &jessica_report_form).await?;
let agg = CommentAggregates::read(pool, inserted_comment.id)
.await
.unwrap();
let agg = CommentAggregates::read(pool, inserted_comment.id).await?;
let read_jessica_report_view =
CommentReportView::read(pool, inserted_jessica_report.id, inserted_timmy.id)
.await
.unwrap();
CommentReportView::read(pool, inserted_jessica_report.id, inserted_timmy.id).await?;
let expected_jessica_report_view = CommentReportView {
comment_report: inserted_jessica_report.clone(),
comment: inserted_comment.clone(),
@ -514,8 +500,7 @@ mod tests {
// Do a batch read of timmys reports
let reports = CommentReportQuery::default()
.list(pool, &timmy_view)
.await
.unwrap();
.await?;
assert_eq!(
reports,
@ -526,19 +511,14 @@ mod tests {
);
// Make sure the counts are correct
let report_count = CommentReportView::get_report_count(pool, inserted_timmy.id, false, None)
.await
.unwrap();
let report_count =
CommentReportView::get_report_count(pool, inserted_timmy.id, false, None).await?;
assert_eq!(2, report_count);
// Try to resolve the report
CommentReport::resolve(pool, inserted_jessica_report.id, inserted_timmy.id)
.await
.unwrap();
CommentReport::resolve(pool, inserted_jessica_report.id, inserted_timmy.id).await?;
let read_jessica_report_view_after_resolve =
CommentReportView::read(pool, inserted_jessica_report.id, inserted_timmy.id)
.await
.unwrap();
CommentReportView::read(pool, inserted_jessica_report.id, inserted_timmy.id).await?;
let mut expected_jessica_report_view_after_resolve = expected_jessica_report_view;
expected_jessica_report_view_after_resolve
@ -588,24 +568,21 @@ mod tests {
..Default::default()
}
.list(pool, &timmy_view)
.await
.unwrap();
.await?;
assert_eq!(reports_after_resolve[0], expected_sara_report_view);
assert_eq!(reports_after_resolve.len(), 1);
// Make sure the counts are correct
let report_count_after_resolved =
CommentReportView::get_report_count(pool, inserted_timmy.id, false, None)
.await
.unwrap();
CommentReportView::get_report_count(pool, inserted_timmy.id, false, None).await?;
assert_eq!(1, report_count_after_resolved);
Person::delete(pool, inserted_timmy.id).await.unwrap();
Person::delete(pool, inserted_sara.id).await.unwrap();
Person::delete(pool, inserted_jessica.id).await.unwrap();
Community::delete(pool, inserted_community.id)
.await
.unwrap();
Instance::delete(pool, inserted_instance.id).await.unwrap();
Person::delete(pool, inserted_timmy.id).await?;
Person::delete(pool, inserted_sara.id).await?;
Person::delete(pool, inserted_jessica.id).await?;
Community::delete(pool, inserted_community.id).await?;
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
}

29
crates/db_views/src/comment_view.rs
View file

@ -423,7 +423,6 @@ impl<'a> CommentQuery<'a> {
#[cfg(test)]
#[expect(clippy::indexing_slicing)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
@ -511,7 +510,7 @@ mod tests {
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await?;
let english_id = Language::read_id_from_code(pool, Some("en")).await?;
let english_id = Language::read_id_from_code(pool, "en").await?;
// Create a comment tree with this hierarchy
// 0
@ -522,7 +521,7 @@ mod tests {
// \
// 5
let comment_form_0 = CommentInsertForm {
language_id: english_id,
language_id: Some(english_id),
..CommentInsertForm::new(
inserted_timmy_person.id,
inserted_post.id,
@ -533,7 +532,7 @@ mod tests {
let inserted_comment_0 = Comment::create(pool, &comment_form_0, None).await?;
let comment_form_1 = CommentInsertForm {
language_id: english_id,
language_id: Some(english_id),
..CommentInsertForm::new(
inserted_sara_person.id,
inserted_post.id,
@ -543,9 +542,9 @@ mod tests {
let inserted_comment_1 =
Comment::create(pool, &comment_form_1, Some(&inserted_comment_0.path)).await?;
let finnish_id = Language::read_id_from_code(pool, Some("fi")).await?;
let finnish_id = Language::read_id_from_code(pool, "fi").await?;
let comment_form_2 = CommentInsertForm {
language_id: finnish_id,
language_id: Some(finnish_id),
..CommentInsertForm::new(
inserted_timmy_person.id,
inserted_post.id,
@ -557,7 +556,7 @@ mod tests {
Comment::create(pool, &comment_form_2, Some(&inserted_comment_0.path)).await?;
let comment_form_3 = CommentInsertForm {
language_id: english_id,
language_id: Some(english_id),
..CommentInsertForm::new(
inserted_timmy_person.id,
inserted_post.id,
@ -567,9 +566,7 @@ mod tests {
let _inserted_comment_3 =
Comment::create(pool, &comment_form_3, Some(&inserted_comment_1.path)).await?;
let polish_id = Language::read_id_from_code(pool, Some("pl"))
.await?
.unwrap();
let polish_id = Language::read_id_from_code(pool, "pl").await?;
let comment_form_4 = CommentInsertForm {
language_id: Some(polish_id),
..CommentInsertForm::new(
@ -655,8 +652,8 @@ mod tests {
.await?;
assert_eq!(
&expected_comment_view_no_person,
read_comment_views_no_person.first().unwrap()
Some(&expected_comment_view_no_person),
read_comment_views_no_person.first()
);
let read_comment_views_with_person = CommentQuery {
@ -832,9 +829,7 @@ mod tests {
assert_length!(5, all_languages);
// change user lang to finnish, should only show one post in finnish and one undetermined
let finnish_id = Language::read_id_from_code(pool, Some("fi"))
.await?
.unwrap();
let finnish_id = Language::read_id_from_code(pool, "fi").await?;
LocalUserLanguage::update(
pool,
vec![finnish_id],
@ -853,8 +848,8 @@ mod tests {
.find(|c| c.comment.language_id == finnish_id);
assert!(finnish_comment.is_some());
assert_eq!(
data.inserted_comment_2.content,
finnish_comment.unwrap().comment.content
Some(&data.inserted_comment_2.content),
finnish_comment.map(|c| &c.comment.content)
);
// now show all comments with undetermined language (which is the default value)

82
crates/db_views/src/post_report_view.rs
View file

@ -284,7 +284,6 @@ impl PostReportQuery {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
#[expect(clippy::indexing_slicing)]
mod tests {
@ -306,27 +305,24 @@ mod tests {
traits::{Crud, Joinable, Reportable},
utils::build_db_pool_for_tests,
};
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "timmy_prv");
let inserted_timmy = Person::create(pool, &new_person).await.unwrap();
let inserted_timmy = Person::create(pool, &new_person).await?;
let new_local_user = LocalUserInsertForm::test_form(inserted_timmy.id);
let timmy_local_user = LocalUser::create(pool, &new_local_user, vec![])
.await
.unwrap();
let timmy_local_user = LocalUser::create(pool, &new_local_user, vec![]).await?;
let timmy_view = LocalUserView {
local_user: timmy_local_user,
local_user_vote_display_mode: LocalUserVoteDisplayMode::default(),
@ -336,12 +332,12 @@ mod tests {
let new_person_2 = PersonInsertForm::test_form(inserted_instance.id, "sara_prv");
let inserted_sara = Person::create(pool, &new_person_2).await.unwrap();
let inserted_sara = Person::create(pool, &new_person_2).await?;
// Add a third person, since new ppl can only report something once.
let new_person_3 = PersonInsertForm::test_form(inserted_instance.id, "jessica_prv");
let inserted_jessica = Person::create(pool, &new_person_3).await.unwrap();
let inserted_jessica = Person::create(pool, &new_person_3).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -349,7 +345,7 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
// Make timmy a mod
let timmy_moderator_form = CommunityModeratorForm {
@ -357,16 +353,14 @@ mod tests {
person_id: inserted_timmy.id,
};
let _inserted_moderator = CommunityModerator::join(pool, &timmy_moderator_form)
.await
.unwrap();
let _inserted_moderator = CommunityModerator::join(pool, &timmy_moderator_form).await?;
let new_post = PostInsertForm::new(
"A test post crv".into(),
inserted_timmy.id,
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
// sara reports
let sara_report_form = PostReportForm {
@ -378,14 +372,14 @@ mod tests {
reason: "from sara".into(),
};
PostReport::report(pool, &sara_report_form).await.unwrap();
PostReport::report(pool, &sara_report_form).await?;
let new_post_2 = PostInsertForm::new(
"A test post crv 2".into(),
inserted_timmy.id,
inserted_community.id,
);
let inserted_post_2 = Post::create(pool, &new_post_2).await.unwrap();
let inserted_post_2 = Post::create(pool, &new_post_2).await?;
// jessica reports
let jessica_report_form = PostReportForm {
@ -397,14 +391,10 @@ mod tests {
reason: "from jessica".into(),
};
let inserted_jessica_report = PostReport::report(pool, &jessica_report_form)
.await
.unwrap();
let inserted_jessica_report = PostReport::report(pool, &jessica_report_form).await?;
let read_jessica_report_view =
PostReportView::read(pool, inserted_jessica_report.id, inserted_timmy.id)
.await
.unwrap();
PostReportView::read(pool, inserted_jessica_report.id, inserted_timmy.id).await?;
assert_eq!(
read_jessica_report_view.post_report,
@ -418,30 +408,23 @@ mod tests {
assert_eq!(read_jessica_report_view.resolver, None);
// Do a batch read of timmys reports
let reports = PostReportQuery::default()
.list(pool, &timmy_view)
.await
.unwrap();
let reports = PostReportQuery::default().list(pool, &timmy_view).await?;
assert_eq!(reports[1].creator.id, inserted_sara.id);
assert_eq!(reports[0].creator.id, inserted_jessica.id);
// Make sure the counts are correct
let report_count = PostReportView::get_report_count(pool, inserted_timmy.id, false, None)
.await
.unwrap();
let report_count =
PostReportView::get_report_count(pool, inserted_timmy.id, false, None).await?;
assert_eq!(2, report_count);
// Pretend the post was removed, and resolve all reports for that object.
// This is called manually in the API for post removals
PostReport::resolve_all_for_object(pool, inserted_jessica_report.post_id, inserted_timmy.id)
.await
.unwrap();
.await?;
let read_jessica_report_view_after_resolve =
PostReportView::read(pool, inserted_jessica_report.id, inserted_timmy.id)
.await
.unwrap();
PostReportView::read(pool, inserted_jessica_report.id, inserted_timmy.id).await?;
assert!(read_jessica_report_view_after_resolve.post_report.resolved);
assert_eq!(
read_jessica_report_view_after_resolve
@ -450,8 +433,10 @@ mod tests {
Some(inserted_timmy.id)
);
assert_eq!(
read_jessica_report_view_after_resolve.resolver.unwrap().id,
inserted_timmy.id
read_jessica_report_view_after_resolve
.resolver
.map(|r| r.id),
Some(inserted_timmy.id)
);
// Do a batch read of timmys reports
@ -461,24 +446,21 @@ mod tests {
..Default::default()
}
.list(pool, &timmy_view)
.await
.unwrap();
.await?;
assert_length!(1, reports_after_resolve);
assert_eq!(reports_after_resolve[0].creator.id, inserted_sara.id);
// Make sure the counts are correct
let report_count_after_resolved =
PostReportView::get_report_count(pool, inserted_timmy.id, false, None)
.await
.unwrap();
PostReportView::get_report_count(pool, inserted_timmy.id, false, None).await?;
assert_eq!(1, report_count_after_resolved);
Person::delete(pool, inserted_timmy.id).await.unwrap();
Person::delete(pool, inserted_sara.id).await.unwrap();
Person::delete(pool, inserted_jessica.id).await.unwrap();
Community::delete(pool, inserted_community.id)
.await
.unwrap();
Instance::delete(pool, inserted_instance.id).await.unwrap();
Person::delete(pool, inserted_timmy.id).await?;
Person::delete(pool, inserted_sara.id).await?;
Person::delete(pool, inserted_jessica.id).await?;
Community::delete(pool, inserted_community.id).await?;
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
}

13
crates/db_views/src/post_view.rs
View file

@ -739,7 +739,6 @@ impl<'a> PostQuery<'a> {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{
post_view::{PaginationCursorData, PostQuery, PostView},
@ -1305,13 +1304,9 @@ mod tests {
let pool = &mut pool.into();
let data = init_data(pool).await?;
let spanish_id = Language::read_id_from_code(pool, Some("es"))
.await?
.expect("spanish should exist");
let spanish_id = Language::read_id_from_code(pool, "es").await?;
let french_id = Language::read_id_from_code(pool, Some("fr"))
.await?
.expect("french should exist");
let french_id = Language::read_id_from_code(pool, "fr").await?;
let post_spanish = PostInsertForm {
language_id: Some(spanish_id),
@ -1690,7 +1685,7 @@ mod tests {
assert_eq!(vec![POST_BY_BOT, POST], names(&post_listings_show_hidden));
// Make sure that hidden field is true.
assert!(&post_listings_show_hidden.first().unwrap().hidden);
assert!(&post_listings_show_hidden.first().is_some_and(|p| p.hidden));
cleanup(data, pool).await
}
@ -1726,7 +1721,7 @@ mod tests {
assert_eq!(vec![POST_BY_BOT, POST], names(&post_listings_show_nsfw));
// Make sure that nsfw field is true.
assert!(&post_listings_show_nsfw.first().unwrap().post.nsfw);
assert!(&post_listings_show_nsfw.first().is_some_and(|p| p.post.nsfw));
cleanup(data, pool).await
}

40
crates/db_views/src/private_message_report_view.rs
View file

@ -111,7 +111,6 @@ impl PrivateMessageReportQuery {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
#[expect(clippy::indexing_slicing)]
mod tests {
@ -127,24 +126,23 @@ mod tests {
traits::{Crud, Reportable},
utils::build_db_pool_for_tests,
};
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person_1 = PersonInsertForm::test_form(inserted_instance.id, "timmy_mrv");
let inserted_timmy = Person::create(pool, &new_person_1).await.unwrap();
let inserted_timmy = Person::create(pool, &new_person_1).await?;
let new_person_2 = PersonInsertForm::test_form(inserted_instance.id, "jessica_mrv");
let inserted_jessica = Person::create(pool, &new_person_2).await.unwrap();
let inserted_jessica = Person::create(pool, &new_person_2).await?;
// timmy sends private message to jessica
let pm_form = PrivateMessageInsertForm::new(
@ -152,7 +150,7 @@ mod tests {
inserted_jessica.id,
"something offensive".to_string(),
);
let pm = PrivateMessage::create(pool, &pm_form).await.unwrap();
let pm = PrivateMessage::create(pool, &pm_form).await?;
// jessica reports private message
let pm_report_form = PrivateMessageReportForm {
@ -161,14 +159,9 @@ mod tests {
private_message_id: pm.id,
reason: "its offensive".to_string(),
};
let pm_report = PrivateMessageReport::report(pool, &pm_report_form)
.await
.unwrap();
let pm_report = PrivateMessageReport::report(pool, &pm_report_form).await?;
let reports = PrivateMessageReportQuery::default()
.list(pool)
.await
.unwrap();
let reports = PrivateMessageReportQuery::default().list(pool).await?;
assert_length!(1, reports);
assert!(!reports[0].private_message_report.resolved);
assert_eq!(inserted_timmy.name, reports[0].private_message_creator.name);
@ -177,28 +170,27 @@ mod tests {
assert_eq!(pm.content, reports[0].private_message.content);
let new_person_3 = PersonInsertForm::test_form(inserted_instance.id, "admin_mrv");
let inserted_admin = Person::create(pool, &new_person_3).await.unwrap();
let inserted_admin = Person::create(pool, &new_person_3).await?;
// admin resolves the report (after taking appropriate action)
PrivateMessageReport::resolve(pool, pm_report.id, inserted_admin.id)
.await
.unwrap();
PrivateMessageReport::resolve(pool, pm_report.id, inserted_admin.id).await?;
let reports = PrivateMessageReportQuery {
unresolved_only: (false),
..Default::default()
}
.list(pool)
.await
.unwrap();
.await?;
assert_length!(1, reports);
assert!(reports[0].private_message_report.resolved);
assert!(reports[0].resolver.is_some());
assert_eq!(
inserted_admin.name,
reports[0].resolver.as_ref().unwrap().name
Some(&inserted_admin.name),
reports[0].resolver.as_ref().map(|r| &r.name)
);
Instance::delete(pool, inserted_instance.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
}

63
crates/db_views/src/private_message_view.rs
View file

@ -173,7 +173,6 @@ impl PrivateMessageQuery {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
#[expect(clippy::indexing_slicing)]
mod tests {
@ -205,45 +204,35 @@ mod tests {
async fn init_data(pool: &mut DbPool<'_>) -> LemmyResult<Data> {
let message_content = String::new();
let instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let timmy_form = PersonInsertForm::test_form(instance.id, "timmy_rav");
let timmy = Person::create(pool, &timmy_form).await.unwrap();
let timmy = Person::create(pool, &timmy_form).await?;
let sara_form = PersonInsertForm::test_form(instance.id, "sara_rav");
let sara = Person::create(pool, &sara_form).await.unwrap();
let sara = Person::create(pool, &sara_form).await?;
let jess_form = PersonInsertForm::test_form(instance.id, "jess_rav");
let jess = Person::create(pool, &jess_form).await.unwrap();
let jess = Person::create(pool, &jess_form).await?;
let sara_timmy_message_form =
PrivateMessageInsertForm::new(sara.id, timmy.id, message_content.clone());
PrivateMessage::create(pool, &sara_timmy_message_form)
.await
.unwrap();
PrivateMessage::create(pool, &sara_timmy_message_form).await?;
let sara_jess_message_form =
PrivateMessageInsertForm::new(sara.id, jess.id, message_content.clone());
PrivateMessage::create(pool, &sara_jess_message_form)
.await
.unwrap();
PrivateMessage::create(pool, &sara_jess_message_form).await?;
let timmy_sara_message_form =
PrivateMessageInsertForm::new(timmy.id, sara.id, message_content.clone());
PrivateMessage::create(pool, &timmy_sara_message_form)
.await
.unwrap();
PrivateMessage::create(pool, &timmy_sara_message_form).await?;
let jess_timmy_message_form =
PrivateMessageInsertForm::new(jess.id, timmy.id, message_content.clone());
PrivateMessage::create(pool, &jess_timmy_message_form)
.await
.unwrap();
PrivateMessage::create(pool, &jess_timmy_message_form).await?;
Ok(Data {
instance,
@ -255,7 +244,7 @@ mod tests {
async fn cleanup(instance_id: InstanceId, pool: &mut DbPool<'_>) -> LemmyResult<()> {
// This also deletes all persons and private messages thanks to sql `on delete cascade`
Instance::delete(pool, instance_id).await.unwrap();
Instance::delete(pool, instance_id).await?;
Ok(())
}
@ -277,8 +266,7 @@ mod tests {
..Default::default()
}
.list(pool, timmy.id)
.await
.unwrap();
.await?;
assert_length!(3, &timmy_messages);
assert_eq!(timmy_messages[0].creator.id, jess.id);
@ -294,8 +282,7 @@ mod tests {
..Default::default()
}
.list(pool, timmy.id)
.await
.unwrap();
.await?;
assert_length!(2, &timmy_unread_messages);
assert_eq!(timmy_unread_messages[0].creator.id, jess.id);
@ -309,8 +296,7 @@ mod tests {
..Default::default()
}
.list(pool, timmy.id)
.await
.unwrap();
.await?;
assert_length!(2, &timmy_sara_messages);
assert_eq!(timmy_sara_messages[0].creator.id, timmy.id);
@ -324,8 +310,7 @@ mod tests {
..Default::default()
}
.list(pool, timmy.id)
.await
.unwrap();
.await?;
assert_length!(1, &timmy_sara_unread_messages);
assert_eq!(timmy_sara_unread_messages[0].creator.id, sara.id);
@ -352,9 +337,7 @@ mod tests {
target_id: sara.id,
};
let inserted_block = PersonBlock::block(pool, &timmy_blocks_sara_form)
.await
.unwrap();
let inserted_block = PersonBlock::block(pool, &timmy_blocks_sara_form).await?;
let expected_block = PersonBlock {
person_id: timmy.id,
@ -369,14 +352,11 @@ mod tests {
..Default::default()
}
.list(pool, timmy.id)
.await
.unwrap();
.await?;
assert_length!(1, &timmy_messages);
let timmy_unread_messages = PrivateMessageView::get_unread_messages(pool, timmy.id)
.await
.unwrap();
let timmy_unread_messages = PrivateMessageView::get_unread_messages(pool, timmy.id).await?;
assert_eq!(timmy_unread_messages, 1);
cleanup(instance.id, pool).await
@ -399,9 +379,7 @@ mod tests {
instance_id: sara.instance_id,
};
let inserted_instance_block = InstanceBlock::block(pool, &timmy_blocks_instance_form)
.await
.unwrap();
let inserted_instance_block = InstanceBlock::block(pool, &timmy_blocks_instance_form).await?;
let expected_instance_block = InstanceBlock {
person_id: timmy.id,
@ -416,14 +394,11 @@ mod tests {
..Default::default()
}
.list(pool, timmy.id)
.await
.unwrap();
.await?;
assert_length!(0, &timmy_messages);
let timmy_unread_messages = PrivateMessageView::get_unread_messages(pool, timmy.id)
.await
.unwrap();
let timmy_unread_messages = PrivateMessageView::get_unread_messages(pool, timmy.id).await?;
assert_eq!(timmy_unread_messages, 0);
cleanup(instance.id, pool).await
}

88
crates/db_views/src/registration_application_view.rs
View file

@ -135,7 +135,6 @@ impl RegistrationApplicationQuery {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::registration_application_view::{
@ -156,38 +155,34 @@ mod tests {
traits::Crud,
utils::build_db_pool_for_tests,
};
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn test_crud() {
async fn test_crud() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let timmy_person_form = PersonInsertForm::test_form(inserted_instance.id, "timmy_rav");
let inserted_timmy_person = Person::create(pool, &timmy_person_form).await.unwrap();
let inserted_timmy_person = Person::create(pool, &timmy_person_form).await?;
let timmy_local_user_form = LocalUserInsertForm::test_form_admin(inserted_timmy_person.id);
let _inserted_timmy_local_user = LocalUser::create(pool, &timmy_local_user_form, vec![])
.await
.unwrap();
let _inserted_timmy_local_user =
LocalUser::create(pool, &timmy_local_user_form, vec![]).await?;
let sara_person_form = PersonInsertForm::test_form(inserted_instance.id, "sara_rav");
let inserted_sara_person = Person::create(pool, &sara_person_form).await.unwrap();
let inserted_sara_person = Person::create(pool, &sara_person_form).await?;
let sara_local_user_form = LocalUserInsertForm::test_form(inserted_sara_person.id);
let inserted_sara_local_user = LocalUser::create(pool, &sara_local_user_form, vec![])
.await
.unwrap();
let inserted_sara_local_user = LocalUser::create(pool, &sara_local_user_form, vec![]).await?;
// Sara creates an application
let sara_app_form = RegistrationApplicationInsertForm {
@ -195,23 +190,17 @@ mod tests {
answer: "LET ME IIIIINN".to_string(),
};
let sara_app = RegistrationApplication::create(pool, &sara_app_form)
.await
.unwrap();
let sara_app = RegistrationApplication::create(pool, &sara_app_form).await?;
let read_sara_app_view = RegistrationApplicationView::read(pool, sara_app.id)
.await
.unwrap();
let read_sara_app_view = RegistrationApplicationView::read(pool, sara_app.id).await?;
let jess_person_form = PersonInsertForm::test_form(inserted_instance.id, "jess_rav");
let inserted_jess_person = Person::create(pool, &jess_person_form).await.unwrap();
let inserted_jess_person = Person::create(pool, &jess_person_form).await?;
let jess_local_user_form = LocalUserInsertForm::test_form(inserted_jess_person.id);
let inserted_jess_local_user = LocalUser::create(pool, &jess_local_user_form, vec![])
.await
.unwrap();
let inserted_jess_local_user = LocalUser::create(pool, &jess_local_user_form, vec![]).await?;
// Sara creates an application
let jess_app_form = RegistrationApplicationInsertForm {
@ -219,13 +208,9 @@ mod tests {
answer: "LET ME IIIIINN".to_string(),
};
let jess_app = RegistrationApplication::create(pool, &jess_app_form)
.await
.unwrap();
let jess_app = RegistrationApplication::create(pool, &jess_app_form).await?;
let read_jess_app_view = RegistrationApplicationView::read(pool, jess_app.id)
.await
.unwrap();
let read_jess_app_view = RegistrationApplicationView::read(pool, jess_app.id).await?;
let mut expected_sara_app_view = RegistrationApplicationView {
registration_application: sara_app.clone(),
@ -291,8 +276,7 @@ mod tests {
..Default::default()
}
.list(pool)
.await
.unwrap();
.await?;
assert_eq!(
apps,
@ -300,9 +284,7 @@ mod tests {
);
// Make sure the counts are correct
let unread_count = RegistrationApplicationView::get_unread_count(pool, false)
.await
.unwrap();
let unread_count = RegistrationApplicationView::get_unread_count(pool, false).await?;
assert_eq!(unread_count, 2);
// Approve the application
@ -311,9 +293,7 @@ mod tests {
deny_reason: None,
};
RegistrationApplication::update(pool, sara_app.id, &approve_form)
.await
.unwrap();
RegistrationApplication::update(pool, sara_app.id, &approve_form).await?;
// Update the local_user row
let approve_local_user_form = LocalUserUpdateForm {
@ -321,13 +301,10 @@ mod tests {
..Default::default()
};
LocalUser::update(pool, inserted_sara_local_user.id, &approve_local_user_form)
.await
.unwrap();
LocalUser::update(pool, inserted_sara_local_user.id, &approve_local_user_form).await?;
let read_sara_app_view_after_approve = RegistrationApplicationView::read(pool, sara_app.id)
.await
.unwrap();
let read_sara_app_view_after_approve =
RegistrationApplicationView::read(pool, sara_app.id).await?;
// Make sure the columns changed
expected_sara_app_view
@ -367,28 +344,23 @@ mod tests {
..Default::default()
}
.list(pool)
.await
.unwrap();
.await?;
assert_eq!(apps_after_resolve, vec![read_jess_app_view]);
// Make sure the counts are correct
let unread_count_after_approve = RegistrationApplicationView::get_unread_count(pool, false)
.await
.unwrap();
let unread_count_after_approve =
RegistrationApplicationView::get_unread_count(pool, false).await?;
assert_eq!(unread_count_after_approve, 1);
// Make sure the not undenied_only has all the apps
let all_apps = RegistrationApplicationQuery::default()
.list(pool)
.await
.unwrap();
let all_apps = RegistrationApplicationQuery::default().list(pool).await?;
assert_eq!(all_apps.len(), 2);
Person::delete(pool, inserted_timmy_person.id)
.await
.unwrap();
Person::delete(pool, inserted_sara_person.id).await.unwrap();
Person::delete(pool, inserted_jess_person.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await.unwrap();
Person::delete(pool, inserted_timmy_person.id).await?;
Person::delete(pool, inserted_sara_person.id).await?;
Person::delete(pool, inserted_jess_person.id).await?;
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
}

69
crates/db_views/src/vote_view.rs
View file

@ -83,7 +83,6 @@ impl VoteView {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::structs::VoteView;
@ -98,26 +97,25 @@ mod tests {
traits::{Bannable, Crud, Likeable},
utils::build_db_pool_for_tests,
};
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
#[tokio::test]
#[serial]
async fn post_and_comment_vote_views() {
async fn post_and_comment_vote_views() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "timmy_vv");
let inserted_timmy = Person::create(pool, &new_person).await.unwrap();
let inserted_timmy = Person::create(pool, &new_person).await?;
let new_person_2 = PersonInsertForm::test_form(inserted_instance.id, "sara_vv");
let inserted_sara = Person::create(pool, &new_person_2).await.unwrap();
let inserted_sara = Person::create(pool, &new_person_2).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -125,21 +123,21 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
let new_post = PostInsertForm::new(
"A test post vv".into(),
inserted_timmy.id,
inserted_community.id,
);
let inserted_post = Post::create(pool, &new_post).await.unwrap();
let inserted_post = Post::create(pool, &new_post).await?;
let comment_form = CommentInsertForm::new(
inserted_timmy.id,
inserted_post.id,
"A test comment vv".into(),
);
let inserted_comment = Comment::create(pool, &comment_form, None).await.unwrap();
let inserted_comment = Comment::create(pool, &comment_form, None).await?;
// Timmy upvotes his own post
let timmy_post_vote_form = PostLikeForm {
@ -147,7 +145,7 @@ mod tests {
person_id: inserted_timmy.id,
score: 1,
};
PostLike::like(pool, &timmy_post_vote_form).await.unwrap();
PostLike::like(pool, &timmy_post_vote_form).await?;
// Sara downvotes timmy's post
let sara_post_vote_form = PostLikeForm {
@ -155,7 +153,7 @@ mod tests {
person_id: inserted_sara.id,
score: -1,
};
PostLike::like(pool, &sara_post_vote_form).await.unwrap();
PostLike::like(pool, &sara_post_vote_form).await?;
let expected_post_vote_views = [
VoteView {
@ -170,9 +168,7 @@ mod tests {
},
];
let read_post_vote_views = VoteView::list_for_post(pool, inserted_post.id, None, None)
.await
.unwrap();
let read_post_vote_views = VoteView::list_for_post(pool, inserted_post.id, None, None).await?;
assert_eq!(read_post_vote_views, expected_post_vote_views);
// Timothy votes down his own comment
@ -182,9 +178,7 @@ mod tests {
person_id: inserted_timmy.id,
score: -1,
};
CommentLike::like(pool, &timmy_comment_vote_form)
.await
.unwrap();
CommentLike::like(pool, &timmy_comment_vote_form).await?;
// Sara upvotes timmy's comment
let sara_comment_vote_form = CommentLikeForm {
@ -193,9 +187,7 @@ mod tests {
person_id: inserted_sara.id,
score: 1,
};
CommentLike::like(pool, &sara_comment_vote_form)
.await
.unwrap();
CommentLike::like(pool, &sara_comment_vote_form).await?;
let expected_comment_vote_views = [
VoteView {
@ -210,9 +202,8 @@ mod tests {
},
];
let read_comment_vote_views = VoteView::list_for_comment(pool, inserted_comment.id, None, None)
.await
.unwrap();
let read_comment_vote_views =
VoteView::list_for_comment(pool, inserted_comment.id, None, None).await?;
assert_eq!(read_comment_vote_views, expected_comment_vote_views);
// Ban timmy from that community
@ -221,36 +212,26 @@ mod tests {
person_id: inserted_timmy.id,
expires: None,
};
CommunityPersonBan::ban(pool, &ban_timmy_form)
.await
.unwrap();
CommunityPersonBan::ban(pool, &ban_timmy_form).await?;
// Make sure creator_banned_from_community is true
let read_comment_vote_views_after_ban =
VoteView::list_for_comment(pool, inserted_comment.id, None, None)
.await
.unwrap();
VoteView::list_for_comment(pool, inserted_comment.id, None, None).await?;
assert!(
read_comment_vote_views_after_ban
assert!(read_comment_vote_views_after_ban
.first()
.unwrap()
.creator_banned_from_community
);
.is_some_and(|c| c.creator_banned_from_community));
let read_post_vote_views_after_ban =
VoteView::list_for_post(pool, inserted_post.id, None, None)
.await
.unwrap();
VoteView::list_for_post(pool, inserted_post.id, None, None).await?;
assert!(
read_post_vote_views_after_ban
assert!(read_post_vote_views_after_ban
.get(1)
.unwrap()
.creator_banned_from_community
);
.is_some_and(|p| p.creator_banned_from_community));
// Cleanup
Instance::delete(pool, inserted_instance.id).await.unwrap();
Instance::delete(pool, inserted_instance.id).await?;
Ok(())
}
}

53
crates/db_views_actor/src/community_view.rs
View file

@ -248,7 +248,6 @@ impl<'a> CommunityQuery<'a> {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use crate::{community_view::CommunityQuery, structs::CommunityView};
@ -264,6 +263,7 @@ mod tests {
utils::{build_db_pool_for_tests, DbPool},
CommunityVisibility,
};
use lemmy_utils::error::LemmyResult;
use serial_test::serial;
use url::Url;
@ -274,21 +274,17 @@ mod tests {
site: Site,
}
async fn init_data(pool: &mut DbPool<'_>) -> Data {
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
async fn init_data(pool: &mut DbPool<'_>) -> LemmyResult<Data> {
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let person_name = "tegan".to_string();
let new_person = PersonInsertForm::test_form(inserted_instance.id, &person_name);
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let local_user_form = LocalUserInsertForm::test_form(inserted_person.id);
let local_user = LocalUser::create(pool, &local_user_form, vec![])
.await
.unwrap();
let local_user = LocalUser::create(pool, &local_user_form, vec![]).await?;
let new_community = CommunityInsertForm::new(
inserted_instance.id,
@ -296,9 +292,9 @@ mod tests {
"nada".to_owned(),
"pubkey".to_string(),
);
let inserted_community = Community::create(pool, &new_community).await.unwrap();
let inserted_community = Community::create(pool, &new_community).await?;
let url = Url::parse("http://example.com").unwrap();
let url = Url::parse("http://example.com")?;
let site = Site {
id: Default::default(),
name: String::new(),
@ -317,32 +313,28 @@ mod tests {
content_warning: None,
};
Data {
Ok(Data {
inserted_instance,
local_user,
inserted_community,
site,
}
})
}
async fn cleanup(data: Data, pool: &mut DbPool<'_>) {
Community::delete(pool, data.inserted_community.id)
.await
.unwrap();
Person::delete(pool, data.local_user.person_id)
.await
.unwrap();
Instance::delete(pool, data.inserted_instance.id)
.await
.unwrap();
async fn cleanup(data: Data, pool: &mut DbPool<'_>) -> LemmyResult<()> {
Community::delete(pool, data.inserted_community.id).await?;
Person::delete(pool, data.local_user.person_id).await?;
Instance::delete(pool, data.inserted_instance.id).await?;
Ok(())
}
#[tokio::test]
#[serial]
async fn local_only_community() {
async fn local_only_community() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let data = init_data(pool).await;
let data = init_data(pool).await?;
Community::update(
pool,
@ -352,15 +344,13 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let unauthenticated_query = CommunityQuery {
..Default::default()
}
.list(&data.site, pool)
.await
.unwrap();
.await?;
assert_eq!(0, unauthenticated_query.len());
let authenticated_query = CommunityQuery {
@ -368,8 +358,7 @@ mod tests {
..Default::default()
}
.list(&data.site, pool)
.await
.unwrap();
.await?;
assert_eq!(1, authenticated_query.len());
let unauthenticated_community =
@ -385,6 +374,6 @@ mod tests {
.await;
assert!(authenticated_community.is_ok());
cleanup(data, pool).await;
cleanup(data, pool).await
}
}

149
crates/federate/src/inboxes.rs
View file

@ -222,7 +222,6 @@ impl<T: DataSource> CommunityInboxCollector<T> {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
#[expect(clippy::indexing_slicing)]
mod tests {
use super::*;
@ -230,6 +229,7 @@ mod tests {
newtypes::{ActivityId, CommunityId, InstanceId, SiteId},
source::activity::{ActorType, SentActivity},
};
use lemmy_utils::error::LemmyResult;
use mockall::{mock, predicate::*};
use serde_json::json;
mock! {
@ -253,13 +253,11 @@ mod tests {
}
#[tokio::test]
async fn test_get_inbox_urls_empty() {
async fn test_get_inbox_urls_empty() -> LemmyResult<()> {
let mut collector = setup_collector();
let activity = SentActivity {
id: ActivityId(1),
ap_id: Url::parse("https://example.com/activities/1")
.unwrap()
.into(),
ap_id: Url::parse("https://example.com/activities/1")?.into(),
data: json!({}),
sensitive: false,
published: Utc::now(),
@ -270,14 +268,16 @@ mod tests {
actor_apub_id: None,
};
let result = collector.get_inbox_urls(&activity).await.unwrap();
let result = collector.get_inbox_urls(&activity).await?;
assert!(result.is_empty());
Ok(())
}
#[tokio::test]
async fn test_get_inbox_urls_send_all_instances() {
async fn test_get_inbox_urls_send_all_instances() -> LemmyResult<()> {
let mut collector = setup_collector();
let site_inbox = Url::parse("https://example.com/inbox").unwrap();
let site_inbox = Url::parse("https://example.com/inbox")?;
let site = Site {
id: SiteId(1),
name: "Test Site".to_string(),
@ -287,7 +287,7 @@ mod tests {
icon: None,
banner: None,
description: None,
actor_id: Url::parse("https://example.com/site").unwrap().into(),
actor_id: Url::parse("https://example.com/site")?.into(),
last_refreshed_at: Utc::now(),
inbox_url: site_inbox.clone().into(),
private_key: None,
@ -303,9 +303,7 @@ mod tests {
let activity = SentActivity {
id: ActivityId(1),
ap_id: Url::parse("https://example.com/activities/1")
.unwrap()
.into(),
ap_id: Url::parse("https://example.com/activities/1")?.into(),
data: json!({}),
sensitive: false,
published: Utc::now(),
@ -316,13 +314,15 @@ mod tests {
actor_apub_id: None,
};
let result = collector.get_inbox_urls(&activity).await.unwrap();
let result = collector.get_inbox_urls(&activity).await?;
assert_eq!(result.len(), 1);
assert_eq!(result[0], site_inbox);
Ok(())
}
#[tokio::test]
async fn test_get_inbox_urls_community_followers() {
async fn test_get_inbox_urls_community_followers() -> LemmyResult<()> {
let mut collector = setup_collector();
let community_id = CommunityId(1);
let url1 = "https://follower1.example.com/inbox";
@ -333,18 +333,22 @@ mod tests {
.expect_get_instance_followed_community_inboxes()
.return_once(move |_, _| {
Ok(vec![
(community_id, Url::parse(url1).unwrap().into()),
(community_id, Url::parse(url2).unwrap().into()),
(
community_id,
Url::parse(url1).map_err(|_| diesel::NotFound)?.into(),
),
(
community_id,
Url::parse(url2).map_err(|_| diesel::NotFound)?.into(),
),
])
});
collector.update_communities().await.unwrap();
collector.update_communities().await?;
let activity = SentActivity {
id: ActivityId(1),
ap_id: Url::parse("https://example.com/activities/1")
.unwrap()
.into(),
ap_id: Url::parse("https://example.com/activities/1")?.into(),
data: json!({}),
sensitive: false,
published: Utc::now(),
@ -355,24 +359,24 @@ mod tests {
actor_apub_id: None,
};
let result = collector.get_inbox_urls(&activity).await.unwrap();
let result = collector.get_inbox_urls(&activity).await?;
assert_eq!(result.len(), 2);
assert!(result.contains(&Url::parse(url1).unwrap()));
assert!(result.contains(&Url::parse(url2).unwrap()));
assert!(result.contains(&Url::parse(url1)?));
assert!(result.contains(&Url::parse(url2)?));
Ok(())
}
#[tokio::test]
async fn test_get_inbox_urls_send_inboxes() {
async fn test_get_inbox_urls_send_inboxes() -> LemmyResult<()> {
let mut collector = setup_collector();
collector.domain = "example.com".to_string();
let inbox_user_1 = Url::parse("https://example.com/user1/inbox").unwrap();
let inbox_user_2 = Url::parse("https://example.com/user2/inbox").unwrap();
let other_domain_inbox = Url::parse("https://other-domain.com/user3/inbox").unwrap();
let inbox_user_1 = Url::parse("https://example.com/user1/inbox")?;
let inbox_user_2 = Url::parse("https://example.com/user2/inbox")?;
let other_domain_inbox = Url::parse("https://other-domain.com/user3/inbox")?;
let activity = SentActivity {
id: ActivityId(1),
ap_id: Url::parse("https://example.com/activities/1")
.unwrap()
.into(),
ap_id: Url::parse("https://example.com/activities/1")?.into(),
data: json!({}),
sensitive: false,
published: Utc::now(),
@ -387,20 +391,22 @@ mod tests {
actor_apub_id: None,
};
let result = collector.get_inbox_urls(&activity).await.unwrap();
let result = collector.get_inbox_urls(&activity).await?;
assert_eq!(result.len(), 2);
assert!(result.contains(&inbox_user_1));
assert!(result.contains(&inbox_user_2));
assert!(!result.contains(&other_domain_inbox));
Ok(())
}
#[tokio::test]
async fn test_get_inbox_urls_combined() {
async fn test_get_inbox_urls_combined() -> LemmyResult<()> {
let mut collector = setup_collector();
collector.domain = "example.com".to_string();
let community_id = CommunityId(1);
let site_inbox = Url::parse("https://example.com/site_inbox").unwrap();
let site_inbox = Url::parse("https://example.com/site_inbox")?;
let site = Site {
id: SiteId(1),
name: "Test Site".to_string(),
@ -410,7 +416,7 @@ mod tests {
icon: None,
banner: None,
description: None,
actor_id: Url::parse("https://example.com/site").unwrap().into(),
actor_id: Url::parse("https://example.com/site")?.into(),
last_refreshed_at: Utc::now(),
inbox_url: site_inbox.clone().into(),
private_key: None,
@ -431,18 +437,18 @@ mod tests {
.return_once(move |_, _| {
Ok(vec![(
community_id,
Url::parse(subdomain_inbox).unwrap().into(),
Url::parse(subdomain_inbox)
.map_err(|_| diesel::NotFound)?
.into(),
)])
});
collector.update_communities().await.unwrap();
let user1_inbox = Url::parse("https://example.com/user1/inbox").unwrap();
let user2_inbox = Url::parse("https://other-domain.com/user2/inbox").unwrap();
collector.update_communities().await?;
let user1_inbox = Url::parse("https://example.com/user1/inbox")?;
let user2_inbox = Url::parse("https://other-domain.com/user2/inbox")?;
let activity = SentActivity {
id: ActivityId(1),
ap_id: Url::parse("https://example.com/activities/1")
.unwrap()
.into(),
ap_id: Url::parse("https://example.com/activities/1")?.into(),
data: json!({}),
sensitive: false,
published: Utc::now(),
@ -456,27 +462,29 @@ mod tests {
actor_apub_id: None,
};
let result = collector.get_inbox_urls(&activity).await.unwrap();
let result = collector.get_inbox_urls(&activity).await?;
assert_eq!(result.len(), 3);
assert!(result.contains(&site_inbox));
assert!(result.contains(&Url::parse(subdomain_inbox).unwrap()));
assert!(result.contains(&Url::parse(subdomain_inbox)?));
assert!(result.contains(&user1_inbox));
assert!(!result.contains(&user2_inbox));
Ok(())
}
#[tokio::test]
async fn test_update_communities() {
async fn test_update_communities() -> LemmyResult<()> {
let mut collector = setup_collector();
let community_id1 = CommunityId(1);
let community_id2 = CommunityId(2);
let community_id3 = CommunityId(3);
let user1_inbox_str = "https://follower1.example.com/inbox";
let user1_inbox = Url::parse(user1_inbox_str).unwrap();
let user1_inbox = Url::parse(user1_inbox_str)?;
let user2_inbox_str = "https://follower2.example.com/inbox";
let user2_inbox = Url::parse(user2_inbox_str).unwrap();
let user2_inbox = Url::parse(user2_inbox_str)?;
let user3_inbox_str = "https://follower3.example.com/inbox";
let user3_inbox = Url::parse(user3_inbox_str).unwrap();
let user3_inbox = Url::parse(user3_inbox_str)?;
collector
.data_source
@ -485,42 +493,57 @@ mod tests {
.returning(move |_, last_fetch| {
if last_fetch == Utc.timestamp_nanos(0) {
Ok(vec![
(community_id1, Url::parse(user1_inbox_str).unwrap().into()),
(community_id2, Url::parse(user2_inbox_str).unwrap().into()),
(
community_id1,
Url::parse(user1_inbox_str)
.map_err(|_| diesel::NotFound)?
.into(),
),
(
community_id2,
Url::parse(user2_inbox_str)
.map_err(|_| diesel::NotFound)?
.into(),
),
])
} else {
Ok(vec![(
community_id3,
Url::parse(user3_inbox_str).unwrap().into(),
Url::parse(user3_inbox_str)
.map_err(|_| diesel::NotFound)?
.into(),
)])
}
});
// First update
collector.update_communities().await.unwrap();
collector.update_communities().await?;
assert_eq!(collector.followed_communities.len(), 2);
assert!(collector.followed_communities[&community_id1].contains(&user1_inbox));
assert!(collector.followed_communities[&community_id2].contains(&user2_inbox));
// Simulate time passing
collector.last_full_communities_fetch = Utc::now() - chrono::TimeDelta::try_minutes(3).unwrap();
collector.last_full_communities_fetch =
Utc::now() - chrono::TimeDelta::try_minutes(3).expect("TimeDelta out of bounds");
collector.last_incremental_communities_fetch =
Utc::now() - chrono::TimeDelta::try_minutes(3).unwrap();
Utc::now() - chrono::TimeDelta::try_minutes(3).expect("TimeDelta out of bounds");
// Second update (incremental)
collector.update_communities().await.unwrap();
collector.update_communities().await?;
assert_eq!(collector.followed_communities.len(), 3);
assert!(collector.followed_communities[&community_id1].contains(&user1_inbox));
assert!(collector.followed_communities[&community_id3].contains(&user3_inbox));
assert!(collector.followed_communities[&community_id2].contains(&user2_inbox));
Ok(())
}
#[tokio::test]
async fn test_get_inbox_urls_no_duplicates() {
async fn test_get_inbox_urls_no_duplicates() -> LemmyResult<()> {
let mut collector = setup_collector();
collector.domain = "example.com".to_string();
let community_id = CommunityId(1);
let site_inbox = Url::parse("https://example.com/site_inbox").unwrap();
let site_inbox = Url::parse("https://example.com/site_inbox")?;
let site_inbox_clone = site_inbox.clone();
let site = Site {
id: SiteId(1),
@ -531,7 +554,7 @@ mod tests {
icon: None,
banner: None,
description: None,
actor_id: Url::parse("https://example.com/site").unwrap().into(),
actor_id: Url::parse("https://example.com/site")?.into(),
last_refreshed_at: Utc::now(),
inbox_url: site_inbox.clone().into(),
private_key: None,
@ -550,13 +573,11 @@ mod tests {
.expect_get_instance_followed_community_inboxes()
.return_once(move |_, _| Ok(vec![(community_id, site_inbox_clone.into())]));
collector.update_communities().await.unwrap();
collector.update_communities().await?;
let activity = SentActivity {
id: ActivityId(1),
ap_id: Url::parse("https://example.com/activities/1")
.unwrap()
.into(),
ap_id: Url::parse("https://example.com/activities/1")?.into(),
data: json!({}),
sensitive: false,
published: Utc::now(),
@ -567,8 +588,10 @@ mod tests {
actor_apub_id: None,
};
let result = collector.get_inbox_urls(&activity).await.unwrap();
let result = collector.get_inbox_urls(&activity).await?;
assert_eq!(result.len(), 1);
assert!(result.contains(&Url::parse("https://example.com/site_inbox").unwrap()));
assert!(result.contains(&Url::parse("https://example.com/site_inbox")?));
Ok(())
}
}

32
crates/utils/src/error.rs
View file

@ -288,7 +288,6 @@ cfg_if! {
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used)]
#![allow(clippy::indexing_slicing)]
use super::*;
use actix_web::{body::MessageBody, ResponseError};
@ -297,21 +296,25 @@ cfg_if! {
use strum::IntoEnumIterator;
#[test]
fn deserializes_no_message() {
fn deserializes_no_message() -> LemmyResult<()> {
let err = LemmyError::from(LemmyErrorType::Banned).error_response();
let json = String::from_utf8(err.into_body().try_into_bytes().unwrap().to_vec()).unwrap();
assert_eq!(&json, "{\"error\":\"banned\"}")
let json = String::from_utf8(err.into_body().try_into_bytes().unwrap_or_default().to_vec())?;
assert_eq!(&json, "{\"error\":\"banned\"}");
Ok(())
}
#[test]
fn deserializes_with_message() {
fn deserializes_with_message() -> LemmyResult<()> {
let reg_banned = LemmyErrorType::PersonIsBannedFromSite(String::from("reason"));
let err = LemmyError::from(reg_banned).error_response();
let json = String::from_utf8(err.into_body().try_into_bytes().unwrap().to_vec()).unwrap();
let json = String::from_utf8(err.into_body().try_into_bytes().unwrap_or_default().to_vec())?;
assert_eq!(
&json,
"{\"error\":\"person_is_banned_from_site\",\"message\":\"reason\"}"
)
);
Ok(())
}
#[test]
@ -328,19 +331,22 @@ cfg_if! {
/// Check if errors match translations. Disabled because many are not translated at all.
#[test]
#[ignore]
fn test_translations_match() {
fn test_translations_match() -> LemmyResult<()> {
#[derive(Deserialize)]
struct Err {
error: String,
}
let translations = read_to_string("translations/translations/en.json").unwrap();
LemmyErrorType::iter().for_each(|e| {
let msg = serde_json::to_string(&e).unwrap();
let msg: Err = serde_json::from_str(&msg).unwrap();
let translations = read_to_string("translations/translations/en.json")?;
for e in LemmyErrorType::iter() {
let msg = serde_json::to_string(&e)?;
let msg: Err = serde_json::from_str(&msg)?;
let msg = msg.error;
assert!(translations.contains(&format!("\"{msg}\"")), "{msg}");
});
}
Ok(())
}
}
}

14
crates/utils/src/rate_limit/rate_limiter.rs
View file

@ -308,10 +308,10 @@ fn split_ipv6(ip: Ipv6Addr) -> ([u8; 6], u8, u8) {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use super::{ActionType, BucketConfig, InstantSecs, RateLimitState, RateLimitedGroup};
use crate::error::LemmyResult;
use pretty_assertions::assert_eq;
#[test]
@ -326,7 +326,7 @@ mod tests {
}
#[test]
fn test_rate_limiter() {
fn test_rate_limiter() -> LemmyResult<()> {
let bucket_configs = enum_map::enum_map! {
ActionType::Message => BucketConfig {
capacity: 2,
@ -350,7 +350,7 @@ mod tests {
"1:2:3:0405:6::",
];
for ip in ips {
let ip = ip.parse().unwrap();
let ip = ip.parse()?;
let message_passed = rate_limiter.check(ActionType::Message, ip, now);
let post_passed = rate_limiter.check(ActionType::Post, ip, now);
assert!(message_passed);
@ -407,7 +407,7 @@ mod tests {
// Do 2 `Message` actions for 1 IP address and expect only the 2nd one to fail
for expected_to_pass in [true, false] {
let ip = "1:2:3:0400::".parse().unwrap();
let ip = "1:2:3:0400::".parse()?;
let passed = rate_limiter.check(ActionType::Message, ip, now);
assert_eq!(passed, expected_to_pass);
}
@ -419,7 +419,7 @@ mod tests {
assert!(rate_limiter.ipv6_buckets.is_empty());
// `remove full buckets` should not remove empty buckets
let ip = "1.1.1.1".parse().unwrap();
let ip = "1.1.1.1".parse()?;
// empty the bucket with 2 requests
assert!(rate_limiter.check(ActionType::Post, ip, now));
assert!(rate_limiter.check(ActionType::Post, ip, now));
@ -429,11 +429,13 @@ mod tests {
// `remove full buckets` should not remove partial buckets
now.secs += 2;
let ip = "1.1.1.1".parse().unwrap();
let ip = "1.1.1.1".parse()?;
// Only make one request, so bucket still has 1 token
assert!(rate_limiter.check(ActionType::Post, ip, now));
rate_limiter.remove_full_buckets(now);
assert!(!rate_limiter.ipv4_buckets.is_empty());
Ok(())
}
}

16
crates/utils/src/utils/markdown/mod.rs
View file

@ -107,7 +107,6 @@ pub fn markdown_check_for_blocked_urls(text: &str, blocklist: &RegexSet) -> Lemm
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use super::*;
@ -245,8 +244,8 @@ mod tests {
}
#[test]
fn test_url_blocking() {
let set = RegexSet::new(vec![r"(https://)?example\.com/?"]).unwrap();
fn test_url_blocking() -> LemmyResult<()> {
let set = RegexSet::new(vec![r"(https://)?example\.com/?"])?;
assert!(
markdown_check_for_blocked_urls(&String::from("[](https://example.com)"), &set).is_err()
@ -274,7 +273,7 @@ mod tests {
)
.is_err());
let set = RegexSet::new(vec![r"(https://)?example\.com/spam\.jpg"]).unwrap();
let set = RegexSet::new(vec![r"(https://)?example\.com/spam\.jpg"])?;
assert!(markdown_check_for_blocked_urls(
&String::from("![](https://example.com/spam.jpg)"),
&set
@ -285,8 +284,7 @@ mod tests {
r"(https://)?quo\.example\.com/?",
r"(https://)?foo\.example\.com/?",
r"(https://)?bar\.example\.com/?",
])
.unwrap();
])?;
assert!(
markdown_check_for_blocked_urls(&String::from("https://baz.example.com"), &set).is_ok()
@ -296,15 +294,17 @@ mod tests {
markdown_check_for_blocked_urls(&String::from("https://bar.example.com"), &set).is_err()
);
let set = RegexSet::new(vec![r"(https://)?example\.com/banned_page"]).unwrap();
let set = RegexSet::new(vec![r"(https://)?example\.com/banned_page"])?;
assert!(
markdown_check_for_blocked_urls(&String::from("https://example.com/page"), &set).is_ok()
);
let set = RegexSet::new(vec![r"(https://)?ex\.mple\.com/?"]).unwrap();
let set = RegexSet::new(vec![r"(https://)?ex\.mple\.com/?"])?;
assert!(markdown_check_for_blocked_urls("example.com", &set).is_ok());
Ok(())
}
#[test]

12
crates/utils/src/utils/slurs.rs
View file

@ -61,16 +61,18 @@ pub(crate) fn slurs_vec_to_str(slurs: &[&str]) -> String {
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod test {
use crate::utils::slurs::{remove_slurs, slur_check, slurs_vec_to_str};
use crate::{
error::LemmyResult,
utils::slurs::{remove_slurs, slur_check, slurs_vec_to_str},
};
use pretty_assertions::assert_eq;
use regex::RegexBuilder;
#[test]
fn test_slur_filter() {
let slur_regex = Some(RegexBuilder::new(r"(fag(g|got|tard)?\b|cock\s?sucker(s|ing)?|ni((g{2,}|q)+|[gq]{2,})[e3r]+(s|z)?|mudslime?s?|kikes?|\bspi(c|k)s?\b|\bchinks?|gooks?|bitch(es|ing|y)?|whor(es?|ing)|\btr(a|@)nn?(y|ies?)|\b(b|re|r)tard(ed)?s?)").case_insensitive(true).build().unwrap());
fn test_slur_filter() -> LemmyResult<()> {
let slur_regex = Some(RegexBuilder::new(r"(fag(g|got|tard)?\b|cock\s?sucker(s|ing)?|ni((g{2,}|q)+|[gq]{2,})[e3r]+(s|z)?|mudslime?s?|kikes?|\bspi(c|k)s?\b|\bchinks?|gooks?|bitch(es|ing|y)?|whor(es?|ing)|\btr(a|@)nn?(y|ies?)|\b(b|re|r)tard(ed)?s?)").case_insensitive(true).build()?);
let test =
"faggot test kike tranny cocksucker retardeds. Capitalized Niggerz. This is a bunch of other safe text.";
let slur_free = "No slurs here";
@ -95,6 +97,8 @@ mod test {
if let Err(slur_vec) = slur_check(test, &slur_regex) {
assert_eq!(&slurs_vec_to_str(&slur_vec), has_slurs_err_str);
}
Ok(())
}
// These helped with testing

4
src/lib.rs
View file

@ -122,9 +122,7 @@ pub async fn start_lemmy_server(args: CmdArgs) -> LemmyResult<()> {
run_advanced_migrations(&mut (&pool).into(), &SETTINGS).await?;
// Initialize the secrets
let secret = Secret::init(&mut (&pool).into())
.await?
.expect("Couldn't initialize secrets.");
let secret = Secret::init(&mut (&pool).into()).await?;
// Make sure the local site is set up.
let site_view = SiteView::read_local(&mut (&pool).into()).await?;

29
src/session_middleware.rs
View file

@ -97,7 +97,6 @@ where
}
#[cfg(test)]
#[expect(clippy::unwrap_used)]
mod tests {
use super::*;
@ -113,7 +112,7 @@ mod tests {
traits::Crud,
utils::build_db_pool_for_tests,
};
use lemmy_utils::rate_limit::RateLimitCell;
use lemmy_utils::{error::LemmyResult, rate_limit::RateLimitCell};
use pretty_assertions::assert_eq;
use reqwest::Client;
use reqwest_middleware::ClientBuilder;
@ -122,13 +121,15 @@ mod tests {
#[tokio::test]
#[serial]
async fn test_session_auth() {
async fn test_session_auth() -> LemmyResult<()> {
// hack, necessary so that config file can be loaded from hardcoded, relative path
set_current_dir("crates/utils").unwrap();
set_current_dir("crates/utils")?;
let pool_ = build_db_pool_for_tests().await;
let pool = &mut (&pool_).into();
let secret = Secret::init(pool).await.unwrap().unwrap();
let secret = Secret::init(pool).await?;
let context = LemmyContext::create(
pool_.clone(),
ClientBuilder::new(Client::default()).build(),
@ -136,29 +137,25 @@ mod tests {
RateLimitCell::with_test_config(),
);
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
.await
.unwrap();
let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string()).await?;
let new_person = PersonInsertForm::test_form(inserted_instance.id, "Gerry9812");
let inserted_person = Person::create(pool, &new_person).await.unwrap();
let inserted_person = Person::create(pool, &new_person).await?;
let local_user_form = LocalUserInsertForm::test_form(inserted_person.id);
let inserted_local_user = LocalUser::create(pool, &local_user_form, vec![])
.await
.unwrap();
let inserted_local_user = LocalUser::create(pool, &local_user_form, vec![]).await?;
let req = TestRequest::default().to_http_request();
let jwt = Claims::generate(inserted_local_user.id, req, &context)
.await
.unwrap();
let jwt = Claims::generate(inserted_local_user.id, req, &context).await?;
let valid = Claims::validate(&jwt, &context).await;
assert!(valid.is_ok());
let num_deleted = Person::delete(pool, inserted_person.id).await.unwrap();
let num_deleted = Person::delete(pool, inserted_person.id).await?;
assert_eq!(1, num_deleted);
Ok(())
}
}