iceshrimp/packages/backend/native-utils/tests/model/repository/antenna.rs

119 lines
3.4 KiB
Rust
Raw Normal View History

2023-06-01 01:24:02 +09:00
mod int_test {
2023-06-03 12:29:48 +09:00
use native_utils::{database, model, util};
2023-06-02 21:48:12 +09:00
2023-05-27 19:52:15 +09:00
use model::{
2023-06-03 12:29:48 +09:00
entity::{antenna, antenna_note, note, user},
2023-05-27 19:52:15 +09:00
repository::Repository,
schema,
};
2023-06-02 20:08:58 +09:00
use pretty_assertions::assert_eq;
2023-06-03 12:29:48 +09:00
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, IntoActiveModel, QueryFilter};
2023-05-27 18:50:07 +09:00
2023-05-27 19:52:15 +09:00
use crate::{cleanup, prepare};
2023-05-27 18:50:07 +09:00
2023-05-27 19:52:15 +09:00
#[tokio::test]
async fn can_pack() {
prepare().await;
let db = database::get_database().unwrap();
2023-05-27 18:50:07 +09:00
2023-05-27 19:52:15 +09:00
let alice_antenna = user::Entity::find()
.filter(user::Column::Username.eq("alice"))
.find_also_related(antenna::Entity)
.one(db)
.await
.unwrap()
.expect("alice not found")
.1
.expect("alice's antenna not found");
2023-05-27 18:50:07 +09:00
2023-05-27 19:52:15 +09:00
let packed = alice_antenna
.to_owned()
.pack()
.await
.expect("Unable to pack");
2023-05-27 18:50:07 +09:00
2023-06-02 17:34:49 +09:00
let packed_by_id = antenna::Model::pack_by_id(alice_antenna.id.to_owned())
.await
.expect("Unable to pack");
2023-06-02 19:22:09 +09:00
let result = schema::Antenna {
2023-06-02 17:34:49 +09:00
id: alice_antenna.id,
created_at: alice_antenna.created_at.into(),
2023-06-03 12:29:48 +09:00
name: "Alice Antenna".to_string(),
2023-06-02 17:34:49 +09:00
keywords: vec![
vec!["foo".to_string(), "bar".to_string()],
vec!["foobar".to_string()],
]
.into(),
exclude_keywords: vec![
vec!["abc".to_string()],
vec!["def".to_string(), "ghi".to_string()],
]
.into(),
2023-06-02 19:22:09 +09:00
src: schema::AntennaSrc::All,
2023-06-02 17:34:49 +09:00
user_list_id: None,
user_group_id: None,
users: vec![].into(),
instances: vec![].into(),
case_sensitive: true,
notify: true,
with_replies: false,
with_file: false,
has_unread_note: false,
};
assert_eq!(packed, result);
assert_eq!(packed_by_id, result);
2023-05-27 18:50:07 +09:00
2023-05-27 19:52:15 +09:00
cleanup().await;
}
2023-05-27 20:02:10 +09:00
#[tokio::test]
async fn unread_note() {
2023-06-03 12:29:48 +09:00
prepare().await;
let db = database::get_database().unwrap();
let (alice, alice_antenna) = user::Entity::find()
.filter(user::Column::Username.eq("alice"))
.find_also_related(antenna::Entity)
.one(db)
.await
.unwrap()
.expect("alice not found");
let alice_antenna = alice_antenna.expect("alice's antenna not found");
let packed = alice_antenna
.to_owned()
.pack()
.await
.expect("Unable to pack");
assert_eq!(packed.has_unread_note, false);
let note_model = note::Entity::find()
.filter(note::Column::UserId.eq(alice.id))
.one(db)
.await
.unwrap()
.expect("note not found");
let antenna_note = antenna_note::Model {
id: util::id::create_id().unwrap(),
antenna_id: alice_antenna.id.to_owned(),
note_id: note_model.id.to_owned(),
read: false,
};
antenna_note
.into_active_model()
.reset_all()
.insert(db)
.await
.unwrap();
let packed = alice_antenna
.to_owned()
.pack()
.await
.expect("Unable to pack");
assert_eq!(packed.has_unread_note, true);
cleanup().await;
2023-05-27 20:02:10 +09:00
}
2023-05-27 18:50:07 +09:00
}