mirror of
https://github.com/LemmyNet/lemmy.git
synced 2024-06-01 08:38:05 +00:00
600ae662a5
Since DB tests execute diesel migrations automatically, concurrent execution causes flaky failures from simultaneous migrations. This can be worked around using `cargo test --workspace -- --test-threads=1`, which is what the CI config does, but this is not intuitive for newcomer developers and unnecessarily slows down the test suite for the majority of tests which are safe to run concurrently. This fixes this issue by integrating with the small test crate `serial_test` and using it to explicitly mark DB tests to run sequentially while allowing all other tests to run in parallel. Additionally, this greatly improves the speed of `cargo test` by disabling doc-tests in all crates, since these are aren't currently used and cargo's doc-test pass, even when no doc-tests exist, has significant overhead. On my machine, this change significantly improves test suite times by about 85%, making it much more practical to develop with tools like `cargo watch` auto-running tests.
263 lines
7.7 KiB
Rust
263 lines
7.7 KiB
Rust
use crate::{ApubObject, Crud};
|
|
use diesel::{dsl::*, result::Error, *};
|
|
use lemmy_db_schema::{naive_now, source::private_message::*, Url};
|
|
|
|
impl Crud<PrivateMessageForm> for PrivateMessage {
|
|
fn read(conn: &PgConnection, private_message_id: i32) -> Result<Self, Error> {
|
|
use lemmy_db_schema::schema::private_message::dsl::*;
|
|
private_message.find(private_message_id).first::<Self>(conn)
|
|
}
|
|
|
|
fn create(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> {
|
|
use lemmy_db_schema::schema::private_message::dsl::*;
|
|
insert_into(private_message)
|
|
.values(private_message_form)
|
|
.get_result::<Self>(conn)
|
|
}
|
|
|
|
fn update(
|
|
conn: &PgConnection,
|
|
private_message_id: i32,
|
|
private_message_form: &PrivateMessageForm,
|
|
) -> Result<Self, Error> {
|
|
use lemmy_db_schema::schema::private_message::dsl::*;
|
|
diesel::update(private_message.find(private_message_id))
|
|
.set(private_message_form)
|
|
.get_result::<Self>(conn)
|
|
}
|
|
}
|
|
|
|
impl ApubObject<PrivateMessageForm> for PrivateMessage {
|
|
fn read_from_apub_id(conn: &PgConnection, object_id: &Url) -> Result<Self, Error>
|
|
where
|
|
Self: Sized,
|
|
{
|
|
use lemmy_db_schema::schema::private_message::dsl::*;
|
|
private_message
|
|
.filter(ap_id.eq(object_id))
|
|
.first::<Self>(conn)
|
|
}
|
|
|
|
fn upsert(conn: &PgConnection, private_message_form: &PrivateMessageForm) -> Result<Self, Error> {
|
|
use lemmy_db_schema::schema::private_message::dsl::*;
|
|
insert_into(private_message)
|
|
.values(private_message_form)
|
|
.on_conflict(ap_id)
|
|
.do_update()
|
|
.set(private_message_form)
|
|
.get_result::<Self>(conn)
|
|
}
|
|
}
|
|
|
|
pub trait PrivateMessage_ {
|
|
fn update_ap_id(
|
|
conn: &PgConnection,
|
|
private_message_id: i32,
|
|
apub_id: Url,
|
|
) -> Result<PrivateMessage, Error>;
|
|
fn update_content(
|
|
conn: &PgConnection,
|
|
private_message_id: i32,
|
|
new_content: &str,
|
|
) -> Result<PrivateMessage, Error>;
|
|
fn update_deleted(
|
|
conn: &PgConnection,
|
|
private_message_id: i32,
|
|
new_deleted: bool,
|
|
) -> Result<PrivateMessage, Error>;
|
|
fn update_read(
|
|
conn: &PgConnection,
|
|
private_message_id: i32,
|
|
new_read: bool,
|
|
) -> Result<PrivateMessage, Error>;
|
|
fn mark_all_as_read(
|
|
conn: &PgConnection,
|
|
for_recipient_id: i32,
|
|
) -> Result<Vec<PrivateMessage>, Error>;
|
|
}
|
|
|
|
impl PrivateMessage_ for PrivateMessage {
|
|
fn update_ap_id(
|
|
conn: &PgConnection,
|
|
private_message_id: i32,
|
|
apub_id: Url,
|
|
) -> Result<PrivateMessage, Error> {
|
|
use lemmy_db_schema::schema::private_message::dsl::*;
|
|
|
|
diesel::update(private_message.find(private_message_id))
|
|
.set(ap_id.eq(apub_id))
|
|
.get_result::<Self>(conn)
|
|
}
|
|
|
|
fn update_content(
|
|
conn: &PgConnection,
|
|
private_message_id: i32,
|
|
new_content: &str,
|
|
) -> Result<PrivateMessage, Error> {
|
|
use lemmy_db_schema::schema::private_message::dsl::*;
|
|
diesel::update(private_message.find(private_message_id))
|
|
.set((content.eq(new_content), updated.eq(naive_now())))
|
|
.get_result::<Self>(conn)
|
|
}
|
|
|
|
fn update_deleted(
|
|
conn: &PgConnection,
|
|
private_message_id: i32,
|
|
new_deleted: bool,
|
|
) -> Result<PrivateMessage, Error> {
|
|
use lemmy_db_schema::schema::private_message::dsl::*;
|
|
diesel::update(private_message.find(private_message_id))
|
|
.set(deleted.eq(new_deleted))
|
|
.get_result::<Self>(conn)
|
|
}
|
|
|
|
fn update_read(
|
|
conn: &PgConnection,
|
|
private_message_id: i32,
|
|
new_read: bool,
|
|
) -> Result<PrivateMessage, Error> {
|
|
use lemmy_db_schema::schema::private_message::dsl::*;
|
|
diesel::update(private_message.find(private_message_id))
|
|
.set(read.eq(new_read))
|
|
.get_result::<Self>(conn)
|
|
}
|
|
|
|
fn mark_all_as_read(
|
|
conn: &PgConnection,
|
|
for_recipient_id: i32,
|
|
) -> Result<Vec<PrivateMessage>, Error> {
|
|
use lemmy_db_schema::schema::private_message::dsl::*;
|
|
diesel::update(
|
|
private_message
|
|
.filter(recipient_id.eq(for_recipient_id))
|
|
.filter(read.eq(false)),
|
|
)
|
|
.set(read.eq(true))
|
|
.get_results::<Self>(conn)
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use crate::{
|
|
establish_unpooled_connection,
|
|
source::private_message::PrivateMessage_,
|
|
Crud,
|
|
ListingType,
|
|
SortType,
|
|
};
|
|
use lemmy_db_schema::source::{private_message::*, user::*};
|
|
use serial_test::serial;
|
|
|
|
#[test]
|
|
#[serial]
|
|
fn test_crud() {
|
|
let conn = establish_unpooled_connection();
|
|
|
|
let creator_form = UserForm {
|
|
name: "creator_pm".into(),
|
|
preferred_username: None,
|
|
password_encrypted: "nope".into(),
|
|
email: None,
|
|
matrix_user_id: None,
|
|
avatar: None,
|
|
banner: None,
|
|
admin: false,
|
|
banned: Some(false),
|
|
published: None,
|
|
updated: None,
|
|
show_nsfw: false,
|
|
theme: "browser".into(),
|
|
default_sort_type: SortType::Hot as i16,
|
|
default_listing_type: ListingType::Subscribed as i16,
|
|
lang: "browser".into(),
|
|
show_avatars: true,
|
|
send_notifications_to_email: false,
|
|
actor_id: None,
|
|
bio: None,
|
|
local: true,
|
|
private_key: None,
|
|
public_key: None,
|
|
last_refreshed_at: None,
|
|
inbox_url: None,
|
|
shared_inbox_url: None,
|
|
};
|
|
|
|
let inserted_creator = User_::create(&conn, &creator_form).unwrap();
|
|
|
|
let recipient_form = UserForm {
|
|
name: "recipient_pm".into(),
|
|
preferred_username: None,
|
|
password_encrypted: "nope".into(),
|
|
email: None,
|
|
matrix_user_id: None,
|
|
avatar: None,
|
|
banner: None,
|
|
admin: false,
|
|
banned: Some(false),
|
|
published: None,
|
|
updated: None,
|
|
show_nsfw: false,
|
|
theme: "browser".into(),
|
|
default_sort_type: SortType::Hot as i16,
|
|
default_listing_type: ListingType::Subscribed as i16,
|
|
lang: "browser".into(),
|
|
show_avatars: true,
|
|
send_notifications_to_email: false,
|
|
actor_id: None,
|
|
bio: None,
|
|
local: true,
|
|
private_key: None,
|
|
public_key: None,
|
|
last_refreshed_at: None,
|
|
inbox_url: None,
|
|
shared_inbox_url: None,
|
|
};
|
|
|
|
let inserted_recipient = User_::create(&conn, &recipient_form).unwrap();
|
|
|
|
let private_message_form = PrivateMessageForm {
|
|
content: "A test private message".into(),
|
|
creator_id: inserted_creator.id,
|
|
recipient_id: inserted_recipient.id,
|
|
deleted: None,
|
|
read: None,
|
|
published: None,
|
|
updated: None,
|
|
ap_id: None,
|
|
local: true,
|
|
};
|
|
|
|
let inserted_private_message = PrivateMessage::create(&conn, &private_message_form).unwrap();
|
|
|
|
let expected_private_message = PrivateMessage {
|
|
id: inserted_private_message.id,
|
|
content: "A test private message".into(),
|
|
creator_id: inserted_creator.id,
|
|
recipient_id: inserted_recipient.id,
|
|
deleted: false,
|
|
read: false,
|
|
updated: None,
|
|
published: inserted_private_message.published,
|
|
ap_id: inserted_private_message.ap_id.to_owned(),
|
|
local: true,
|
|
};
|
|
|
|
let read_private_message = PrivateMessage::read(&conn, inserted_private_message.id).unwrap();
|
|
let updated_private_message =
|
|
PrivateMessage::update(&conn, inserted_private_message.id, &private_message_form).unwrap();
|
|
let deleted_private_message =
|
|
PrivateMessage::update_deleted(&conn, inserted_private_message.id, true).unwrap();
|
|
let marked_read_private_message =
|
|
PrivateMessage::update_read(&conn, inserted_private_message.id, true).unwrap();
|
|
User_::delete(&conn, inserted_creator.id).unwrap();
|
|
User_::delete(&conn, inserted_recipient.id).unwrap();
|
|
|
|
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);
|
|
}
|
|
}
|