{
- "@context": [
- "https://www.w3.org/ns/activitystreams",
- {
- "stickied": "as:stickied",
- "pt": "https://join-lemmy.org#",
- "sc": "http://schema.org#",
- "matrixUserId": {
- "type": "sc:Text",
- "id": "as:alsoKnownAs"
- },
- "sensitive": "as:sensitive",
- "comments_enabled": {
- "type": "sc:Boolean",
- "id": "pt:commentsEnabled"
- },
- "moderators": "as:moderators"
- },
- "https://w3id.org/security/v1"
- ],
"type": "Service",
"id": "https://enterprise.lemmy.ml/",
"name": "Enterprise",
"type": "Image",
"url": "https://enterprise.lemmy.ml/pictrs/image/XenaYI5hTn.png"
},
- "matrix_user_id": "@picard:matrix.org",
+ "matrixUserId": "@picard:matrix.org",
"inbox": "https://enterprise.lemmy.ml/u/picard/inbox",
"outbox": "https://enterprise.lemmy.ml/u/picard/outbox",
"endpoints": {
{
+ "@context": [
+ "https://www.w3.org/ns/activitystreams",
+ {
+ "ostatus": "http://ostatus.org#",
+ "atomUri": "ostatus:atomUri"
+ }
+ ],
"id": "https://mastodon.madrid/users/felix/statuses/107224289116410645/activity",
"type": "Create",
"actor": "https://mastodon.madrid/users/felix",
--- /dev/null
+{
+ "@context": "https://www.w3.org/ns/activitystreams",
+ "id": "https://masto.asonix.dog/1ea87517-63c5-4118-8831-460ee641b2cf",
+ "type": "Follow",
+ "actor": "https://masto.asonix.dog/users/asonix",
+ "object": "https://ds9.lemmy.ml/c/testcom"
+}
--- /dev/null
+{
+ "@context": "https://www.w3.org/ns/activitystreams",
+ "id": "https://masto.asonix.dog/users/asonix#follows/449/undo",
+ "type": "Undo",
+ "actor": "https://masto.asonix.dog/users/asonix",
+ "object": {
+ "id": "https://masto.asonix.dog/1ea87517-63c5-4118-8831-460ee641b2cf",
+ "type": "Follow",
+ "actor": "https://masto.asonix.dog/users/asonix",
+ "object": "https://ds9.lemmy.ml/c/testcom"
+ }
+}
+
}
},
"sensitive": false,
- "likes": "https://friends.grishka.me/posts/66561/likes"
+ "likes": "https://friends.grishka.me/posts/66561/likes",
+ "@context": [
+ "https://www.w3.org/ns/activitystreams",
+ {
+ "sensitive": "as:sensitive"
+ }
+ ]
}
\ No newline at end of file
#[cfg(test)]
mod tests {
use super::*;
- use crate::objects::{
- community::tests::parse_lemmy_community,
- person::tests::parse_lemmy_person,
- tests::{file_to_json_object, init_context},
+ use crate::{
+ objects::{
+ community::tests::parse_lemmy_community,
+ person::tests::parse_lemmy_person,
+ tests::init_context,
+ },
+ protocol::tests::file_to_json_object,
};
use lemmy_apub_lib::activity_queue::create_activity_queue;
use lemmy_db_schema::{
published: Some(convert_datetime(self.published)),
updated: self.updated.map(convert_datetime),
tag: maa.tags,
- unparsed: Default::default(),
};
Ok(note)
#[cfg(test)]
pub(crate) mod tests {
use super::*;
- use crate::objects::{
- community::{tests::parse_lemmy_community, ApubCommunity},
- instance::ApubSite,
- person::{tests::parse_lemmy_person, ApubPerson},
- post::ApubPost,
- tests::{file_to_json_object, init_context},
+ use crate::{
+ objects::{
+ community::{tests::parse_lemmy_community, ApubCommunity},
+ instance::ApubSite,
+ person::{tests::parse_lemmy_person, ApubPerson},
+ post::ApubPost,
+ tests::init_context,
+ },
+ protocol::tests::file_to_json_object,
};
use assert_json_diff::assert_json_include;
use lemmy_apub_lib::activity_queue::create_activity_queue;
public_key: self.get_public_key()?,
published: Some(convert_datetime(self.published)),
updated: self.updated.map(convert_datetime),
- unparsed: Default::default(),
};
Ok(group)
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
- use crate::objects::{
- instance::tests::parse_lemmy_instance,
- tests::{file_to_json_object, init_context},
+ use crate::{
+ objects::{instance::tests::parse_lemmy_instance, tests::init_context},
+ protocol::tests::file_to_json_object,
};
use lemmy_apub_lib::activity_queue::create_activity_queue;
use lemmy_db_schema::{source::site::Site, traits::Crud};
use crate::{
check_is_apub_id_valid,
objects::get_summary_from_string_or_source,
- protocol::{objects::instance::Instance, ImageObject, Source, Unparsed},
+ protocol::{objects::instance::Instance, ImageObject, Source},
};
use activitystreams_kinds::actor::ServiceType;
use chrono::NaiveDateTime;
public_key: self.get_public_key()?,
published: convert_datetime(self.published),
updated: self.updated.map(convert_datetime),
- unparsed: Unparsed::default(),
};
Ok(instance)
}
#[cfg(test)]
pub(crate) mod tests {
use super::*;
- use crate::objects::tests::{file_to_json_object, init_context};
+ use crate::{objects::tests::init_context, protocol::tests::file_to_json_object};
use lemmy_apub_lib::activity_queue::create_activity_queue;
use lemmy_db_schema::traits::Crud;
use serial_test::serial;
use lemmy_websocket::{chat_server::ChatServer, LemmyContext};
use reqwest::Client;
use reqwest_middleware::ClientBuilder;
- use serde::de::DeserializeOwned;
- use std::{fs::File, io::BufReader, sync::Arc};
+ use std::sync::Arc;
use tokio::sync::Mutex;
// TODO: would be nice if we didnt have to use a full context for tests.
.start();
LemmyContext::create(pool, chat_server, client, activity_queue, settings, secret)
}
-
- pub(crate) fn file_to_json_object<T: DeserializeOwned>(path: &str) -> Result<T, LemmyError> {
- let file = File::open(path)?;
- let reader = BufReader::new(file);
- Ok(serde_json::from_reader(reader)?)
- }
}
}),
public_key: self.get_public_key()?,
updated: self.updated.map(convert_datetime),
- unparsed: Default::default(),
inbox: self.inbox_url.clone().into(),
};
Ok(person)
use crate::{
objects::{
instance::{tests::parse_lemmy_instance, ApubSite},
- tests::{file_to_json_object, init_context},
+ tests::init_context,
},
- protocol::objects::instance::Instance,
+ protocol::{objects::instance::Instance, tests::file_to_json_object},
};
use lemmy_apub_lib::activity_queue::create_activity_queue;
use lemmy_db_schema::{source::site::Site, traits::Crud};
stickied: Some(self.stickied),
published: Some(convert_datetime(self.published)),
updated: self.updated.map(convert_datetime),
- unparsed: Default::default(),
};
Ok(page)
}
#[cfg(test)]
mod tests {
use super::*;
- use crate::objects::{
- community::tests::parse_lemmy_community,
- person::tests::parse_lemmy_person,
- post::ApubPost,
- tests::{file_to_json_object, init_context},
+ use crate::{
+ objects::{
+ community::tests::parse_lemmy_community,
+ person::tests::parse_lemmy_person,
+ post::ApubPost,
+ tests::init_context,
+ },
+ protocol::tests::file_to_json_object,
};
use lemmy_apub_lib::activity_queue::create_activity_queue;
use lemmy_db_schema::source::site::Site;
source: Some(Source::new(self.content.clone())),
published: Some(convert_datetime(self.published)),
updated: self.updated.map(convert_datetime),
- unparsed: Default::default(),
};
Ok(note)
}
#[cfg(test)]
mod tests {
use super::*;
- use crate::objects::{
- person::ApubPerson,
- tests::{file_to_json_object, init_context},
+ use crate::{
+ objects::{person::ApubPerson, tests::init_context},
+ protocol::tests::file_to_json_object,
};
use assert_json_diff::assert_json_include;
use lemmy_apub_lib::activity_queue::create_activity_queue;
pub(crate) target: ObjectId<SiteOrCommunity>,
#[serde(rename = "type")]
pub(crate) kind: BlockType,
+ pub(crate) id: Url,
+
/// Quick and dirty solution.
/// TODO: send a separate Delete activity instead
pub(crate) remove_data: Option<bool>,
/// block reason, written to mod log
pub(crate) summary: Option<String>,
- pub(crate) id: Url,
+ pub(crate) expires: Option<DateTime<FixedOffset>>,
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
- pub(crate) expires: Option<DateTime<FixedOffset>>,
}
tests::test_parse_lemmy_item,
};
- #[actix_rt::test]
- async fn test_parse_lemmy_block() {
+ #[test]
+ fn test_parse_lemmy_block() {
test_parse_lemmy_item::<BlockUser>("assets/lemmy/activities/block/block_user.json").unwrap();
test_parse_lemmy_item::<UndoBlockUser>("assets/lemmy/activities/block/undo_block_user.json")
.unwrap();
#[serde(rename = "type")]
pub(crate) kind: UndoType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[serde(rename = "type")]
pub(crate) kind: AddType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[serde(rename = "type")]
pub(crate) kind: AnnounceType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
tests::test_parse_lemmy_item,
};
- #[actix_rt::test]
- async fn test_parse_lemmy_community() {
+ #[test]
+ fn test_parse_lemmy_community_activities() {
test_parse_lemmy_item::<AnnounceActivity>(
"assets/lemmy/activities/community/announce_create_page.json",
)
pub(crate) kind: RemoveType,
pub(crate) target: Url,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[serde(rename = "type")]
pub(crate) kind: FlagType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[serde(rename = "type")]
pub(crate) kind: UpdateType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[serde(rename = "type")]
pub(crate) kind: CreateOrUpdateType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[cfg(test)]
mod tests {
- use crate::{
- context::WithContext,
- objects::tests::file_to_json_object,
- protocol::{
- activities::create_or_update::{
- comment::CreateOrUpdateComment,
- post::CreateOrUpdatePost,
- private_message::CreateOrUpdatePrivateMessage,
- },
- tests::test_parse_lemmy_item,
+ use crate::protocol::{
+ activities::create_or_update::{
+ comment::CreateOrUpdateComment,
+ post::CreateOrUpdatePost,
+ private_message::CreateOrUpdatePrivateMessage,
},
+ tests::test_parse_lemmy_item,
};
- #[actix_rt::test]
- async fn test_parse_create_or_update() {
+ #[test]
+ fn test_parse_lemmy_create_or_update() {
test_parse_lemmy_item::<CreateOrUpdatePost>(
"assets/lemmy/activities/create_or_update/create_page.json",
)
"assets/lemmy/activities/create_or_update/create_private_message.json",
)
.unwrap();
-
- file_to_json_object::<WithContext<CreateOrUpdateComment>>(
- "assets/pleroma/activities/create_note.json",
- )
- .unwrap();
- file_to_json_object::<WithContext<CreateOrUpdateComment>>(
- "assets/smithereen/activities/create_note.json",
- )
- .unwrap();
- file_to_json_object::<CreateOrUpdateComment>("assets/mastodon/activities/create_note.json")
- .unwrap();
-
- file_to_json_object::<CreateOrUpdatePost>("assets/lotide/activities/create_page.json").unwrap();
- file_to_json_object::<CreateOrUpdateComment>("assets/lotide/activities/create_note_reply.json")
- .unwrap();
-
- file_to_json_object::<CreateOrUpdateComment>("assets/friendica/activities/create_note.json")
- .unwrap();
}
}
#[serde(rename = "type")]
pub(crate) kind: CreateOrUpdateType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
pub(crate) object: ChatMessage,
#[serde(rename = "type")]
pub(crate) kind: CreateOrUpdateType,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[serde(deserialize_with = "crate::deserialize_one_or_many")]
pub(crate) to: Vec<Url>,
pub(crate) object: IdOrNestedObject,
+ #[serde(rename = "type")]
+ pub(crate) kind: DeleteType,
+ pub(crate) id: Url,
+
#[serde(deserialize_with = "crate::deserialize_one_or_many")]
#[serde(default)]
#[serde(skip_serializing_if = "Vec::is_empty")]
pub(crate) cc: Vec<Url>,
- #[serde(rename = "type")]
- pub(crate) kind: DeleteType,
/// If summary is present, this is a mod action (Remove in Lemmy terms). Otherwise, its a user
/// deleting their own content.
pub(crate) summary: Option<String>,
- pub(crate) id: Url,
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[cfg(test)]
mod tests {
- use crate::{
- context::WithContext,
- objects::tests::file_to_json_object,
- protocol::{
- activities::deletion::{delete::Delete, undo_delete::UndoDelete},
- tests::test_parse_lemmy_item,
- },
+ use crate::protocol::{
+ activities::deletion::{delete::Delete, undo_delete::UndoDelete},
+ tests::test_parse_lemmy_item,
};
- #[actix_rt::test]
- async fn test_parse_deletion() {
+ #[test]
+ fn test_parse_lemmy_deletion() {
test_parse_lemmy_item::<Delete>("assets/lemmy/activities/deletion/remove_note.json").unwrap();
test_parse_lemmy_item::<Delete>("assets/lemmy/activities/deletion/delete_page.json").unwrap();
"assets/lemmy/activities/deletion/undo_delete_private_message.json",
)
.unwrap();
-
- file_to_json_object::<WithContext<Delete>>("assets/pleroma/activities/delete.json").unwrap();
- file_to_json_object::<WithContext<Delete>>("assets/mastodon/activities/delete.json").unwrap();
}
}
#[serde(deserialize_with = "crate::deserialize_one_or_many")]
pub(crate) to: Vec<Url>,
pub(crate) object: Delete,
+ #[serde(rename = "type")]
+ pub(crate) kind: UndoType,
+ pub(crate) id: Url,
+
#[serde(deserialize_with = "crate::deserialize_one_or_many")]
#[serde(default)]
#[serde(skip_serializing_if = "Vec::is_empty")]
pub(crate) cc: Vec<Url>,
- #[serde(rename = "type")]
- pub(crate) kind: UndoType,
- pub(crate) id: Url,
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[serde(rename = "type")]
pub(crate) kind: AcceptType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[serde(rename = "type")]
pub(crate) kind: FollowType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[cfg(test)]
mod tests {
- use crate::{
- context::WithContext,
- objects::tests::file_to_json_object,
- protocol::{
- activities::following::{
- accept::AcceptFollowCommunity,
- follow::FollowCommunity,
- undo_follow::UndoFollowCommunity,
- },
- tests::test_parse_lemmy_item,
+ use crate::protocol::{
+ activities::following::{
+ accept::AcceptFollowCommunity,
+ follow::FollowCommunity,
+ undo_follow::UndoFollowCommunity,
},
+ tests::test_parse_lemmy_item,
};
- #[actix_rt::test]
- async fn test_parse_lemmy_accept_follow() {
+ #[test]
+ fn test_parse_lemmy_accept_follow() {
test_parse_lemmy_item::<FollowCommunity>("assets/lemmy/activities/following/follow.json")
.unwrap();
test_parse_lemmy_item::<AcceptFollowCommunity>("assets/lemmy/activities/following/accept.json")
"assets/lemmy/activities/following/undo_follow.json",
)
.unwrap();
-
- file_to_json_object::<WithContext<FollowCommunity>>("assets/pleroma/activities/follow.json")
- .unwrap();
}
}
#[serde(rename = "type")]
pub(crate) kind: UndoType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
Create,
Update,
}
+
+#[cfg(test)]
+mod tests {
+ use crate::protocol::{
+ activities::{
+ create_or_update::{comment::CreateOrUpdateComment, post::CreateOrUpdatePost},
+ deletion::delete::Delete,
+ following::{follow::FollowCommunity, undo_follow::UndoFollowCommunity},
+ },
+ tests::test_json,
+ };
+
+ #[test]
+ fn test_parse_smithereen_activities() {
+ test_json::<CreateOrUpdateComment>("assets/smithereen/activities/create_note.json").unwrap();
+ }
+
+ #[test]
+ fn test_parse_pleroma_activities() {
+ test_json::<CreateOrUpdateComment>("assets/pleroma/activities/create_note.json").unwrap();
+ test_json::<Delete>("assets/pleroma/activities/delete.json").unwrap();
+ test_json::<FollowCommunity>("assets/pleroma/activities/follow.json").unwrap();
+ }
+
+ #[test]
+ fn test_parse_mastodon_activities() {
+ test_json::<CreateOrUpdateComment>("assets/mastodon/activities/create_note.json").unwrap();
+ test_json::<Delete>("assets/mastodon/activities/delete.json").unwrap();
+ test_json::<FollowCommunity>("assets/mastodon/activities/follow.json").unwrap();
+ test_json::<UndoFollowCommunity>("assets/mastodon/activities/undo_follow.json").unwrap();
+ }
+
+ #[test]
+ fn test_parse_lotide_activities() {
+ test_json::<CreateOrUpdatePost>("assets/lotide/activities/create_page.json").unwrap();
+ test_json::<CreateOrUpdateComment>("assets/lotide/activities/create_note_reply.json").unwrap();
+ }
+
+ #[test]
+ fn test_parse_friendica_activities() {
+ test_json::<CreateOrUpdateComment>("assets/friendica/activities/create_note.json").unwrap();
+ }
+}
tests::test_parse_lemmy_item,
};
- #[actix_rt::test]
- async fn test_parse_lemmy_voting() {
+ #[test]
+ fn test_parse_lemmy_voting() {
test_parse_lemmy_item::<Vote>("assets/lemmy/activities/voting/like_note.json").unwrap();
test_parse_lemmy_item::<Vote>("assets/lemmy/activities/voting/dislike_page.json").unwrap();
#[serde(rename = "type")]
pub(crate) kind: UndoType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
#[serde(rename = "type")]
pub(crate) kind: VoteType,
pub(crate) id: Url,
+
#[serde(flatten)]
pub(crate) unparsed: Unparsed,
}
tests::test_parse_lemmy_item,
};
- #[actix_rt::test]
- async fn test_parse_lemmy_collections() {
+ #[test]
+ fn test_parse_lemmy_collections() {
test_parse_lemmy_item::<GroupFollowers>("assets/lemmy/collections/group_followers.json")
.unwrap();
let outbox =
#[cfg(test)]
pub(crate) mod tests {
- use crate::objects::tests::file_to_json_object;
+ use crate::context::WithContext;
use assert_json_diff::assert_json_include;
use lemmy_utils::LemmyError;
use serde::{de::DeserializeOwned, Serialize};
- use std::collections::HashMap;
+ use std::{collections::HashMap, fs::File, io::BufReader};
+
+ pub(crate) fn file_to_json_object<T: DeserializeOwned>(path: &str) -> Result<T, LemmyError> {
+ let file = File::open(path)?;
+ let reader = BufReader::new(file);
+ Ok(serde_json::from_reader(reader)?)
+ }
+
+ pub(crate) fn test_json<T: DeserializeOwned>(path: &str) -> Result<WithContext<T>, LemmyError> {
+ file_to_json_object::<WithContext<T>>(path)
+ }
/// Check that json deserialize -> serialize -> deserialize gives identical file as initial one.
/// Ensures that there are no breaking changes in sent data.
use crate::{
objects::{person::ApubPerson, private_message::ApubPrivateMessage},
- protocol::{Source, Unparsed},
+ protocol::Source,
};
use chrono::{DateTime, FixedOffset};
use lemmy_apub_lib::{object_id::ObjectId, values::MediaTypeHtml};
#[serde(deserialize_with = "crate::deserialize_one")]
pub(crate) to: [ObjectId<ApubPerson>; 1],
pub(crate) content: String,
+
pub(crate) media_type: Option<MediaTypeHtml>,
pub(crate) source: Option<Source>,
pub(crate) published: Option<DateTime<FixedOffset>>,
pub(crate) updated: Option<DateTime<FixedOffset>>,
- #[serde(flatten)]
- pub(crate) unparsed: Unparsed,
}
/// https://docs.pleroma.social/backend/development/ap_extensions/#chatmessages
community_outbox::ApubCommunityOutbox,
},
objects::{community::ApubCommunity, get_summary_from_string_or_source},
- protocol::{objects::Endpoints, ImageObject, Source, Unparsed},
+ protocol::{objects::Endpoints, ImageObject, Source},
};
use activitystreams_kinds::actor::GroupType;
use chrono::{DateTime, FixedOffset};
#[serde(rename = "type")]
pub(crate) kind: GroupType,
pub(crate) id: ObjectId<ApubCommunity>,
- /// username, set at account creation and can never be changed
+ /// username, set at account creation and usually fixed after that
pub(crate) preferred_username: String,
- /// title (can be changed at any time)
+ /// displayname
pub(crate) name: String,
+ pub(crate) inbox: Url,
+ pub(crate) followers: Url,
+ pub(crate) public_key: PublicKey,
+
pub(crate) summary: Option<String>,
pub(crate) source: Option<Source>,
pub(crate) icon: Option<ImageObject>,
pub(crate) sensitive: Option<bool>,
// lemmy extension
pub(crate) moderators: Option<ObjectId<ApubCommunityModerators>>,
- pub(crate) inbox: Url,
pub(crate) outbox: ObjectId<ApubCommunityOutbox>,
- pub(crate) followers: Url,
pub(crate) endpoints: Option<Endpoints>,
- pub(crate) public_key: PublicKey,
pub(crate) published: Option<DateTime<FixedOffset>>,
pub(crate) updated: Option<DateTime<FixedOffset>>,
- #[serde(flatten)]
- pub(crate) unparsed: Unparsed,
}
impl Group {
use crate::{
objects::instance::ApubSite,
- protocol::{ImageObject, Source, Unparsed},
+ protocol::{ImageObject, Source},
};
use activitystreams_kinds::actor::ServiceType;
use chrono::{DateTime, FixedOffset};
pub(crate) id: ObjectId<ApubSite>,
// site name
pub(crate) name: String,
+ pub(crate) inbox: Url,
+ /// mandatory field in activitypub, lemmy currently serves an empty outbox
+ pub(crate) outbox: Url,
+ pub(crate) public_key: PublicKey,
+
// sidebar
pub(crate) content: Option<String>,
pub(crate) source: Option<Source>,
pub(crate) icon: Option<ImageObject>,
/// instance banner
pub(crate) image: Option<ImageObject>,
- pub(crate) inbox: Url,
- /// mandatory field in activitypub, currently empty in lemmy
- pub(crate) outbox: Url,
- pub(crate) public_key: PublicKey,
pub(crate) published: DateTime<FixedOffset>,
pub(crate) updated: Option<DateTime<FixedOffset>>,
- #[serde(flatten)]
- pub(crate) unparsed: Unparsed,
}
#[cfg(test)]
mod tests {
- use crate::{
- context::WithContext,
- objects::tests::file_to_json_object,
- protocol::{
- objects::{
- chat_message::ChatMessage,
- group::Group,
- instance::Instance,
- note::Note,
- page::Page,
- person::Person,
- tombstone::Tombstone,
- },
- tests::test_parse_lemmy_item,
+ use crate::protocol::{
+ objects::{
+ chat_message::ChatMessage,
+ group::Group,
+ instance::Instance,
+ note::Note,
+ page::Page,
+ person::Person,
+ tombstone::Tombstone,
},
+ tests::{test_json, test_parse_lemmy_item},
};
- #[actix_rt::test]
- async fn test_parse_objects_lemmy() {
+ #[test]
+ fn test_parse_objects_lemmy() {
test_parse_lemmy_item::<Instance>("assets/lemmy/objects/instance.json").unwrap();
test_parse_lemmy_item::<Group>("assets/lemmy/objects/group.json").unwrap();
test_parse_lemmy_item::<Person>("assets/lemmy/objects/person.json").unwrap();
test_parse_lemmy_item::<Tombstone>("assets/lemmy/objects/tombstone.json").unwrap();
}
- #[actix_rt::test]
- async fn test_parse_objects_pleroma() {
- file_to_json_object::<WithContext<Person>>("assets/pleroma/objects/person.json").unwrap();
- file_to_json_object::<WithContext<Note>>("assets/pleroma/objects/note.json").unwrap();
- file_to_json_object::<WithContext<ChatMessage>>("assets/pleroma/objects/chat_message.json")
- .unwrap();
+ #[test]
+ fn test_parse_objects_pleroma() {
+ test_json::<Person>("assets/pleroma/objects/person.json").unwrap();
+ test_json::<Note>("assets/pleroma/objects/note.json").unwrap();
+ test_json::<ChatMessage>("assets/pleroma/objects/chat_message.json").unwrap();
}
- #[actix_rt::test]
- async fn test_parse_objects_smithereen() {
- file_to_json_object::<WithContext<Person>>("assets/smithereen/objects/person.json").unwrap();
- file_to_json_object::<Note>("assets/smithereen/objects/note.json").unwrap();
+ #[test]
+ fn test_parse_objects_smithereen() {
+ test_json::<Person>("assets/smithereen/objects/person.json").unwrap();
+ test_json::<Note>("assets/smithereen/objects/note.json").unwrap();
}
- #[actix_rt::test]
- async fn test_parse_objects_mastodon() {
- file_to_json_object::<WithContext<Person>>("assets/mastodon/objects/person.json").unwrap();
- file_to_json_object::<WithContext<Note>>("assets/mastodon/objects/note.json").unwrap();
+ #[test]
+ fn test_parse_objects_mastodon() {
+ test_json::<Person>("assets/mastodon/objects/person.json").unwrap();
+ test_json::<Note>("assets/mastodon/objects/note.json").unwrap();
}
- #[actix_rt::test]
- async fn test_parse_objects_lotide() {
- file_to_json_object::<WithContext<Group>>("assets/lotide/objects/group.json").unwrap();
- file_to_json_object::<WithContext<Person>>("assets/lotide/objects/person.json").unwrap();
- file_to_json_object::<WithContext<Note>>("assets/lotide/objects/note.json").unwrap();
- file_to_json_object::<WithContext<Page>>("assets/lotide/objects/page.json").unwrap();
- file_to_json_object::<WithContext<Tombstone>>("assets/lotide/objects/tombstone.json").unwrap();
+ #[test]
+ fn test_parse_objects_lotide() {
+ test_json::<Group>("assets/lotide/objects/group.json").unwrap();
+ test_json::<Person>("assets/lotide/objects/person.json").unwrap();
+ test_json::<Note>("assets/lotide/objects/note.json").unwrap();
+ test_json::<Page>("assets/lotide/objects/page.json").unwrap();
+ test_json::<Tombstone>("assets/lotide/objects/tombstone.json").unwrap();
}
- #[actix_rt::test]
- async fn test_parse_object_friendica() {
- file_to_json_object::<WithContext<Person>>("assets/friendica/objects/person.json").unwrap();
- file_to_json_object::<WithContext<Note>>("assets/friendica/objects/note.json").unwrap();
+ #[test]
+ fn test_parse_object_friendica() {
+ test_json::<Person>("assets/friendica/objects/person.json").unwrap();
+ test_json::<Note>("assets/friendica/objects/note.json").unwrap();
}
}
fetcher::post_or_comment::PostOrComment,
mentions::Mention,
objects::{comment::ApubComment, person::ApubPerson, post::ApubPost},
- protocol::{Source, Unparsed},
+ protocol::Source,
};
use activitystreams_kinds::object::NoteType;
use chrono::{DateTime, FixedOffset};
#[serde(deserialize_with = "crate::deserialize_one_or_many")]
pub(crate) cc: Vec<Url>,
pub(crate) content: String,
+ pub(crate) in_reply_to: ObjectId<PostOrComment>,
+
pub(crate) media_type: Option<MediaTypeHtml>,
#[serde(default)]
pub(crate) source: SourceCompat,
- pub(crate) in_reply_to: ObjectId<PostOrComment>,
pub(crate) published: Option<DateTime<FixedOffset>>,
pub(crate) updated: Option<DateTime<FixedOffset>>,
#[serde(default)]
pub(crate) tag: Vec<Mention>,
- #[serde(flatten)]
- pub(crate) unparsed: Unparsed,
}
/// Pleroma puts a raw string in the source, so we have to handle it here for deserialization to work
use crate::{
objects::{community::ApubCommunity, person::ApubPerson, post::ApubPost},
- protocol::{ImageObject, Source, Unparsed},
+ protocol::{ImageObject, Source},
};
use chrono::{DateTime, FixedOffset};
use lemmy_apub_lib::{
pub(crate) attributed_to: ObjectId<ApubPerson>,
#[serde(deserialize_with = "crate::deserialize_one_or_many")]
pub(crate) to: Vec<Url>,
+ pub(crate) name: String,
+
#[serde(default)]
#[serde(deserialize_with = "crate::deserialize_one_or_many")]
pub(crate) cc: Vec<Url>,
- pub(crate) name: String,
pub(crate) content: Option<String>,
pub(crate) media_type: Option<MediaTypeHtml>,
pub(crate) source: Option<Source>,
pub(crate) stickied: Option<bool>,
pub(crate) published: Option<DateTime<FixedOffset>>,
pub(crate) updated: Option<DateTime<FixedOffset>>,
- #[serde(flatten)]
- pub(crate) unparsed: Unparsed,
}
impl Page {
use crate::{
objects::person::ApubPerson,
- protocol::{objects::Endpoints, ImageObject, Source, Unparsed},
+ protocol::{objects::Endpoints, ImageObject, Source},
};
use chrono::{DateTime, FixedOffset};
use lemmy_apub_lib::{object_id::ObjectId, signatures::PublicKey};
#[serde(rename = "type")]
pub(crate) kind: UserTypes,
pub(crate) id: ObjectId<ApubPerson>,
- /// username, set at account creation and can never be changed
+ /// username, set at account creation and usually fixed after that
pub(crate) preferred_username: String,
- /// displayname (can be changed at any time)
+ pub(crate) inbox: Url,
+ /// mandatory field in activitypub, lemmy currently serves an empty outbox
+ pub(crate) outbox: Url,
+ pub(crate) public_key: PublicKey,
+
+ /// displayname
pub(crate) name: Option<String>,
pub(crate) summary: Option<String>,
pub(crate) source: Option<Source>,
/// user banner
pub(crate) image: Option<ImageObject>,
pub(crate) matrix_user_id: Option<String>,
- pub(crate) inbox: Url,
- /// mandatory field in activitypub, currently empty in lemmy
- pub(crate) outbox: Url,
pub(crate) endpoints: Option<Endpoints>,
- pub(crate) public_key: PublicKey,
pub(crate) published: Option<DateTime<FixedOffset>>,
pub(crate) updated: Option<DateTime<FixedOffset>>,
- #[serde(flatten)]
- pub(crate) unparsed: Unparsed,
}
projects / lemmy.git / commitdiff