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

Support listing type for person (fixes #4146) (#4487)

Browse source 
* Support listing type for person (fixes #4146)

* add test
This commit is contained in:
Nutomic 2024-03-01 17:53:20 +01:00 committed by GitHub
parent c5e54a318a
commit 08b01a377d
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 77 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
Cargo.lock generated
View file

@ -2755,6 +2755,7 @@ dependencies = [
"diesel",
"diesel-async",
"lemmy_db_schema",
"lemmy_utils",
"pretty_assertions",
"serde",
"serde_with",

2
crates/apub/src/api/search.rs
View file

@ -104,6 +104,7 @@ pub async fn search(
users = PersonQuery {
sort,
search_term: (Some(q)),
listing_type: (listing_type),
page: (page),
limit: (limit),
}
@ -174,6 +175,7 @@ pub async fn search(
PersonQuery {
sort,
search_term: (Some(q)),
listing_type: (listing_type),
page: (page),
limit: (limit),
}

1
crates/db_views_actor/Cargo.toml
View file

@ -40,6 +40,7 @@ serial_test = { workspace = true }
tokio = { workspace = true }
pretty_assertions = { workspace = true }
url.workspace = true
lemmy_utils.workspace = true
[package.metadata.cargo-machete]
ignored = ["strum"]

119
crates/db_views_actor/src/person_view.rs
View file

@ -23,6 +23,7 @@ use lemmy_db_schema::{
Queries,
ReadFn,
},
ListingType,
SortType,
};
use serde::{Deserialize, Serialize};
@ -115,6 +116,15 @@ fn queries<'a>(
let (limit, offset) = limit_and_offset(options.page, options.limit)?;
query = query.limit(limit).offset(offset);
if let Some(listing_type) = options.listing_type {
query = match listing_type {
// return nothing as its not possible to follow users
ListingType::Subscribed => query.limit(0),
ListingType::Local => query.filter(person::local.eq(true)),
_ => query,
};
}
}
}
query.load::<PersonView>(&mut conn).await
@ -141,6 +151,7 @@ impl PersonView {
pub struct PersonQuery {
pub sort: Option<SortType>,
pub search_term: Option<String>,
pub listing_type: Option<ListingType>,
pub page: Option<i64>,
pub limit: Option<i64>,
}
@ -168,6 +179,7 @@ mod tests {
traits::Crud,
utils::build_db_pool_for_tests,
};
use lemmy_utils::error::LemmyResult;
use pretty_assertions::assert_eq;
use serial_test::serial;
@ -178,64 +190,59 @@ mod tests {
bob_local_user: LocalUser,
}
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 alice_form = PersonInsertForm::builder()
.name("alice".to_string())
.public_key("pubkey".to_string())
.instance_id(inserted_instance.id)
.local(Some(true))
.build();
let alice = Person::create(pool, &alice_form).await.unwrap();
let alice = Person::create(pool, &alice_form).await?;
let alice_local_user_form = LocalUserInsertForm::builder()
.person_id(alice.id)
.password_encrypted(String::new())
.build();
let alice_local_user = LocalUser::create(pool, &alice_local_user_form)
.await
.unwrap();
let alice_local_user = LocalUser::create(pool, &alice_local_user_form).await?;
let bob_form = PersonInsertForm::builder()
.name("bob".to_string())
.bot_account(Some(true))
.public_key("pubkey".to_string())
.instance_id(inserted_instance.id)
.local(Some(false))
.build();
let bob = Person::create(pool, &bob_form).await.unwrap();
let bob = Person::create(pool, &bob_form).await?;
let bob_local_user_form = LocalUserInsertForm::builder()
.person_id(bob.id)
.password_encrypted(String::new())
.build();
let bob_local_user = LocalUser::create(pool, &bob_local_user_form).await.unwrap();
let bob_local_user = LocalUser::create(pool, &bob_local_user_form).await?;
Data {
Ok(Data {
alice,
alice_local_user,
bob,
bob_local_user,
}
})
}
async fn cleanup(data: Data, pool: &mut DbPool<'_>) {
LocalUser::delete(pool, data.alice_local_user.id)
.await
.unwrap();
LocalUser::delete(pool, data.bob_local_user.id)
.await
.unwrap();
Person::delete(pool, data.alice.id).await.unwrap();
Person::delete(pool, data.bob.id).await.unwrap();
Instance::delete(pool, data.bob.instance_id).await.unwrap();
async fn cleanup(data: Data, pool: &mut DbPool<'_>) -> LemmyResult<()> {
LocalUser::delete(pool, data.alice_local_user.id).await?;
LocalUser::delete(pool, data.bob_local_user.id).await?;
Person::delete(pool, data.alice.id).await?;
Person::delete(pool, data.bob.id).await?;
Instance::delete(pool, data.bob.instance_id).await?;
Ok(())
}
#[tokio::test]
#[serial]
async fn exclude_deleted() {
async fn exclude_deleted() -> 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?;
Person::update(
pool,
@ -245,8 +252,7 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let read = PersonView::read(pool, data.alice.id).await;
assert_eq!(read.err(), Some(NotFound));
@ -256,20 +262,19 @@ mod tests {
..Default::default()
}
.list(pool)
.await
.unwrap();
.await?;
assert_length!(1, list);
assert_eq!(list[0].person.id, data.bob.id);
cleanup(data, pool).await;
cleanup(data, pool).await
}
#[tokio::test]
#[serial]
async fn list_banned() {
async fn list_banned() -> 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?;
Person::update(
pool,
@ -279,22 +284,21 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let list = PersonView::banned(pool).await.unwrap();
let list = PersonView::banned(pool).await?;
assert_length!(1, list);
assert_eq!(list[0].person.id, data.alice.id);
cleanup(data, pool).await;
cleanup(data, pool).await
}
#[tokio::test]
#[serial]
async fn list_admins() {
async fn list_admins() -> 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?;
LocalUser::update(
pool,
@ -304,22 +308,45 @@ mod tests {
..Default::default()
},
)
.await
.unwrap();
.await?;
let list = PersonView::admins(pool).await.unwrap();
let list = PersonView::admins(pool).await?;
assert_length!(1, list);
assert_eq!(list[0].person.id, data.alice.id);
let is_admin = PersonView::read(pool, data.alice.id)
.await
.unwrap()
.is_admin;
let is_admin = PersonView::read(pool, data.alice.id).await?.is_admin;
assert!(is_admin);
let is_admin = PersonView::read(pool, data.bob.id).await.unwrap().is_admin;
let is_admin = PersonView::read(pool, data.bob.id).await?.is_admin;
assert!(!is_admin);
cleanup(data, pool).await;
cleanup(data, pool).await
}
#[tokio::test]
#[serial]
async fn listing_type() -> LemmyResult<()> {
let pool = &build_db_pool_for_tests().await;
let pool = &mut pool.into();
let data = init_data(pool).await?;
let list = PersonQuery {
listing_type: Some(ListingType::Local),
..Default::default()
}
.list(pool)
.await?;
assert_length!(1, list);
assert_eq!(list[0].person.id, data.alice.id);
let list = PersonQuery {
listing_type: Some(ListingType::All),
..Default::default()
}
.list(pool)
.await?;
assert_length!(2, list);
cleanup(data, pool).await
}
}