rudeshark.net/packages/backend/native-utils/tests/model/repository/antenna.rs
2023-06-02 23:48:28 -04:00

119 lines
3.4 KiB
Rust

mod int_test {
use native_utils::{database, model, util};
use model::{
entity::{antenna, antenna_note, note, user},
repository::Repository,
schema,
};
use pretty_assertions::assert_eq;
use sea_orm::{ActiveModelTrait, ColumnTrait, EntityTrait, IntoActiveModel, QueryFilter};
use crate::{cleanup, prepare};
#[tokio::test]
async fn can_pack() {
prepare().await;
let db = database::get_database().unwrap();
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");
let packed = alice_antenna
.to_owned()
.pack()
.await
.expect("Unable to pack");
let packed_by_id = antenna::Model::pack_by_id(alice_antenna.id.to_owned())
.await
.expect("Unable to pack");
let result = schema::Antenna {
id: alice_antenna.id,
created_at: alice_antenna.created_at.into(),
name: "Alice Antenna".to_string(),
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(),
src: schema::AntennaSrc::All,
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);
cleanup().await;
}
#[tokio::test]
async fn unread_note() {
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;
}
}