crates/db_schema/src/impls/activity.rs

   1 use crate::{
   2   newtypes::DbUrl,
   3   schema::activity::dsl::{activity, ap_id},
   4   source::activity::{Activity, ActivityInsertForm, ActivityUpdateForm},
   5   traits::Crud,
   6   utils::{get_conn, DbPool},
   7 };
   8 use diesel::{dsl::insert_into, result::Error, ExpressionMethods, QueryDsl};
   9 use diesel_async::RunQueryDsl;
  10
  11 #[async_trait]
  12 impl Crud for Activity {
  13   type InsertForm = ActivityInsertForm;
  14   type UpdateForm = ActivityUpdateForm;
  15   type IdType = i32;
  16   async fn read(pool: &mut DbPool<'_>, activity_id: i32) -> Result<Self, Error> {
  17     let conn = &mut get_conn(pool).await?;
  18     activity.find(activity_id).first::<Self>(conn).await
  19   }
  20
  21   async fn create(pool: &mut DbPool<'_>, new_activity: &Self::InsertForm) -> Result<Self, Error> {
  22     let conn = &mut get_conn(pool).await?;
  23     insert_into(activity)
  24       .values(new_activity)
  25       .get_result::<Self>(conn)
  26       .await
  27   }
  28
  29   async fn update(
  30     pool: &mut DbPool<'_>,
  31     activity_id: i32,
  32     new_activity: &Self::UpdateForm,
  33   ) -> Result<Self, Error> {
  34     let conn = &mut get_conn(pool).await?;
  35     diesel::update(activity.find(activity_id))
  36       .set(new_activity)
  37       .get_result::<Self>(conn)
  38       .await
  39   }
  40   async fn delete(pool: &mut DbPool<'_>, activity_id: i32) -> Result<usize, Error> {
  41     let conn = &mut get_conn(pool).await?;
  42     diesel::delete(activity.find(activity_id))
  43       .execute(conn)
  44       .await
  45   }
  46 }
  47
  48 impl Activity {
  49   pub async fn read_from_apub_id(
  50     pool: &mut DbPool<'_>,
  51     object_id: &DbUrl,
  52   ) -> Result<Activity, Error> {
  53     let conn = &mut get_conn(pool).await?;
  54     activity
  55       .filter(ap_id.eq(object_id))
  56       .first::<Self>(conn)
  57       .await
  58   }
  59 }
  60
  61 #[cfg(test)]
  62 mod tests {
  63   use super::*;
  64   use crate::{
  65     newtypes::DbUrl,
  66     source::{
  67       activity::{Activity, ActivityInsertForm},
  68       instance::Instance,
  69       person::{Person, PersonInsertForm},
  70     },
  71     utils::build_db_pool_for_tests,
  72   };
  73   use serde_json::Value;
  74   use serial_test::serial;
  75   use url::Url;
  76
  77   #[tokio::test]
  78   #[serial]
  79   async fn test_crud() {
  80     let pool = &build_db_pool_for_tests().await;
  81     let pool = &mut pool.into();
  82
  83     let inserted_instance = Instance::read_or_create(pool, "my_domain.tld".to_string())
  84       .await
  85       .unwrap();
  86
  87     let creator_form = PersonInsertForm::builder()
  88       .name("activity_creator_ pm".into())
  89       .public_key("pubkey".to_string())
  90       .instance_id(inserted_instance.id)
  91       .build();
  92
  93     let inserted_creator = Person::create(pool, &creator_form).await.unwrap();
  94
  95     let ap_id_: DbUrl = Url::parse(
  96       "https://enterprise.lemmy.ml/activities/delete/f1b5d57c-80f8-4e03-a615-688d552e946c",
  97     )
  98     .unwrap()
  99     .into();
 100     let test_json: Value = serde_json::from_str(
 101       r#"{
 102     "@context": "https://www.w3.org/ns/activitystreams",
 103     "id": "https://enterprise.lemmy.ml/activities/delete/f1b5d57c-80f8-4e03-a615-688d552e946c",
 104     "type": "Delete",
 105     "actor": "https://enterprise.lemmy.ml/u/riker",
 106     "to": "https://www.w3.org/ns/activitystreams#Public",
 107     "cc": [
 108         "https://enterprise.lemmy.ml/c/main/"
 109     ],
 110     "object": "https://enterprise.lemmy.ml/post/32"
 111     }"#,
 112     )
 113     .unwrap();
 114     let activity_form = ActivityInsertForm {
 115       ap_id: ap_id_.clone(),
 116       data: test_json.clone(),
 117       local: Some(true),
 118       sensitive: Some(false),
 119       updated: None,
 120     };
 121
 122     let inserted_activity = Activity::create(pool, &activity_form).await.unwrap();
 123
 124     let expected_activity = Activity {
 125       ap_id: ap_id_.clone(),
 126       id: inserted_activity.id,
 127       data: test_json,
 128       local: true,
 129       sensitive: false,
 130       published: inserted_activity.published,
 131       updated: None,
 132     };
 133
 134     let read_activity = Activity::read(pool, inserted_activity.id).await.unwrap();
 135     let read_activity_by_apub_id = Activity::read_from_apub_id(pool, &ap_id_).await.unwrap();
 136     Person::delete(pool, inserted_creator.id).await.unwrap();
 137     Activity::delete(pool, inserted_activity.id).await.unwrap();
 138
 139     assert_eq!(expected_activity, read_activity);
 140     assert_eq!(expected_activity, read_activity_by_apub_id);
 141     assert_eq!(expected_activity, inserted_activity);
 142   }
 143 }