2023-11-15 12:05:07 +00:00
|
|
|
extern crate fediwiki;
|
2023-11-16 09:25:54 +00:00
|
|
|
|
2023-11-16 14:27:35 +00:00
|
|
|
mod common;
|
|
|
|
|
2023-11-17 13:36:56 +00:00
|
|
|
use crate::common::{follow_instance, get_query, patch, post, TestData};
|
2023-11-16 14:27:35 +00:00
|
|
|
use common::get;
|
2023-11-21 15:27:18 +00:00
|
|
|
use fediwiki::api::{CreateArticleData, EditArticleData, GetArticleData, ResolveObject};
|
2023-11-16 09:25:54 +00:00
|
|
|
use fediwiki::error::MyResult;
|
2023-11-15 12:05:07 +00:00
|
|
|
use fediwiki::federation::objects::article::DbArticle;
|
2023-11-16 11:48:57 +00:00
|
|
|
use fediwiki::federation::objects::instance::DbInstance;
|
|
|
|
use serial_test::serial;
|
|
|
|
use url::Url;
|
|
|
|
|
2023-11-15 12:05:07 +00:00
|
|
|
#[tokio::test]
|
2023-11-16 11:48:57 +00:00
|
|
|
#[serial]
|
2023-11-22 14:59:22 +00:00
|
|
|
async fn test_create_read_and_edit_article() -> MyResult<()> {
|
2023-11-17 13:36:56 +00:00
|
|
|
let data = TestData::start();
|
2023-11-15 12:05:07 +00:00
|
|
|
|
2023-11-16 12:38:41 +00:00
|
|
|
// error on nonexistent article
|
2023-11-21 15:27:18 +00:00
|
|
|
let get_article = GetArticleData {
|
2023-11-16 12:38:41 +00:00
|
|
|
title: "Manu_Chao".to_string(),
|
|
|
|
};
|
2023-11-20 15:48:29 +00:00
|
|
|
let not_found = get_query::<DbArticle, _>(
|
|
|
|
data.hostname_alpha,
|
|
|
|
&"article".to_string(),
|
|
|
|
Some(get_article.clone()),
|
|
|
|
)
|
|
|
|
.await;
|
2023-11-16 12:38:41 +00:00
|
|
|
assert!(not_found.is_err());
|
|
|
|
|
|
|
|
// create article
|
2023-11-21 15:27:18 +00:00
|
|
|
let create_article = CreateArticleData {
|
2023-11-16 12:38:41 +00:00
|
|
|
title: get_article.title.to_string(),
|
|
|
|
};
|
2023-11-17 13:36:56 +00:00
|
|
|
let create_res: DbArticle = post(data.hostname_alpha, "article", &create_article).await?;
|
2023-11-16 12:38:41 +00:00
|
|
|
assert_eq!(create_article.title, create_res.title);
|
|
|
|
assert!(create_res.local);
|
|
|
|
|
|
|
|
// now article can be read
|
2023-11-20 15:48:29 +00:00
|
|
|
let get_res: DbArticle = get_query(
|
|
|
|
data.hostname_alpha,
|
|
|
|
&"article".to_string(),
|
|
|
|
Some(get_article.clone()),
|
|
|
|
)
|
|
|
|
.await?;
|
2023-11-16 12:38:41 +00:00
|
|
|
assert_eq!(create_article.title, get_res.title);
|
2023-11-22 14:59:22 +00:00
|
|
|
assert!(get_res.text.is_empty());
|
2023-11-16 12:38:41 +00:00
|
|
|
assert!(get_res.local);
|
|
|
|
|
2023-11-22 14:59:22 +00:00
|
|
|
// edit article
|
|
|
|
let edit_form = EditArticleData {
|
|
|
|
ap_id: create_res.ap_id.clone(),
|
|
|
|
new_text: "Lorem Ipsum 2".to_string(),
|
|
|
|
};
|
|
|
|
let edit_res: DbArticle = patch(data.hostname_alpha, "article", &edit_form).await?;
|
|
|
|
assert_eq!(edit_form.new_text, edit_res.text);
|
|
|
|
assert_eq!(1, edit_res.edits.len());
|
|
|
|
|
2023-11-17 13:36:56 +00:00
|
|
|
data.stop()
|
2023-11-15 12:05:07 +00:00
|
|
|
}
|
2023-11-15 14:07:02 +00:00
|
|
|
|
|
|
|
#[tokio::test]
|
2023-11-16 11:48:57 +00:00
|
|
|
#[serial]
|
2023-11-16 09:25:54 +00:00
|
|
|
async fn test_follow_instance() -> MyResult<()> {
|
2023-11-17 13:36:56 +00:00
|
|
|
let data = TestData::start();
|
2023-11-15 14:07:02 +00:00
|
|
|
|
2023-11-16 11:48:57 +00:00
|
|
|
// check initial state
|
2023-11-17 13:36:56 +00:00
|
|
|
let alpha_instance: DbInstance = get(data.hostname_alpha, "instance").await?;
|
2023-11-16 11:48:57 +00:00
|
|
|
assert_eq!(0, alpha_instance.follows.len());
|
2023-11-17 13:36:56 +00:00
|
|
|
let beta_instance: DbInstance = get(data.hostname_beta, "instance").await?;
|
2023-11-16 11:48:57 +00:00
|
|
|
assert_eq!(0, beta_instance.followers.len());
|
|
|
|
|
2023-11-17 13:36:56 +00:00
|
|
|
follow_instance(data.hostname_alpha, &data.hostname_beta).await?;
|
2023-11-16 11:48:57 +00:00
|
|
|
|
|
|
|
// check that follow was federated
|
2023-11-17 13:36:56 +00:00
|
|
|
let beta_instance: DbInstance = get(data.hostname_beta, "instance").await?;
|
2023-11-16 11:48:57 +00:00
|
|
|
assert_eq!(1, beta_instance.followers.len());
|
|
|
|
|
2023-11-17 13:36:56 +00:00
|
|
|
let alpha_instance: DbInstance = get(data.hostname_alpha, "instance").await?;
|
2023-11-16 11:48:57 +00:00
|
|
|
assert_eq!(1, alpha_instance.follows.len());
|
2023-11-16 09:25:54 +00:00
|
|
|
|
2023-11-17 13:36:56 +00:00
|
|
|
data.stop()
|
2023-11-16 09:25:54 +00:00
|
|
|
}
|
2023-11-16 15:40:43 +00:00
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
#[serial]
|
|
|
|
async fn test_synchronize_articles() -> MyResult<()> {
|
2023-11-17 13:36:56 +00:00
|
|
|
let data = TestData::start();
|
2023-11-16 15:40:43 +00:00
|
|
|
|
|
|
|
// create article on alpha
|
2023-11-21 15:27:18 +00:00
|
|
|
let create_article = CreateArticleData {
|
2023-11-16 15:40:43 +00:00
|
|
|
title: "Manu_Chao".to_string(),
|
|
|
|
};
|
2023-11-17 13:36:56 +00:00
|
|
|
let create_res: DbArticle = post(data.hostname_alpha, "article", &create_article).await?;
|
2023-11-16 15:40:43 +00:00
|
|
|
assert_eq!(create_article.title, create_res.title);
|
2023-11-22 14:59:22 +00:00
|
|
|
assert_eq!(0, create_res.edits.len());
|
2023-11-16 15:40:43 +00:00
|
|
|
assert!(create_res.local);
|
|
|
|
|
|
|
|
// article is not yet on beta
|
2023-11-21 15:27:18 +00:00
|
|
|
let get_article = GetArticleData {
|
2023-11-16 15:40:43 +00:00
|
|
|
title: "Manu_Chao".to_string(),
|
|
|
|
};
|
|
|
|
let get_res = get_query::<DbArticle, _>(
|
2023-11-17 13:36:56 +00:00
|
|
|
data.hostname_beta,
|
2023-11-17 11:23:14 +00:00
|
|
|
&"article".to_string(),
|
2023-11-16 15:40:43 +00:00
|
|
|
Some(get_article.clone()),
|
|
|
|
)
|
|
|
|
.await;
|
|
|
|
assert!(get_res.is_err());
|
|
|
|
|
|
|
|
// fetch alpha instance on beta, articles are also fetched automatically
|
|
|
|
let resolve_object = ResolveObject {
|
2023-11-17 13:36:56 +00:00
|
|
|
id: Url::parse(&format!("http://{}", data.hostname_alpha))?,
|
2023-11-16 15:40:43 +00:00
|
|
|
};
|
2023-11-17 13:36:56 +00:00
|
|
|
get_query::<DbInstance, _>(data.hostname_beta, "resolve_object", Some(resolve_object)).await?;
|
2023-11-16 15:40:43 +00:00
|
|
|
|
|
|
|
// get the article and compare
|
|
|
|
let get_res: DbArticle = get_query(
|
2023-11-17 13:36:56 +00:00
|
|
|
data.hostname_beta,
|
2023-11-17 11:23:14 +00:00
|
|
|
&"article".to_string(),
|
2023-11-16 15:40:43 +00:00
|
|
|
Some(get_article.clone()),
|
|
|
|
)
|
|
|
|
.await?;
|
|
|
|
assert_eq!(create_res.ap_id, get_res.ap_id);
|
|
|
|
assert_eq!(create_article.title, get_res.title);
|
2023-11-22 14:59:22 +00:00
|
|
|
assert_eq!(0, get_res.edits.len());
|
|
|
|
assert!(get_res.text.is_empty());
|
2023-11-16 15:40:43 +00:00
|
|
|
assert!(!get_res.local);
|
|
|
|
|
2023-11-17 13:36:56 +00:00
|
|
|
data.stop()
|
2023-11-16 15:40:43 +00:00
|
|
|
}
|
2023-11-17 13:22:31 +00:00
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
#[serial]
|
2023-11-22 14:59:22 +00:00
|
|
|
async fn test_edit_local_article() -> MyResult<()> {
|
2023-11-17 13:36:56 +00:00
|
|
|
let data = TestData::start();
|
|
|
|
|
|
|
|
follow_instance(data.hostname_alpha, data.hostname_beta).await?;
|
2023-11-17 13:22:31 +00:00
|
|
|
|
|
|
|
// create new article
|
2023-11-21 15:27:18 +00:00
|
|
|
let create_form = CreateArticleData {
|
2023-11-17 13:22:31 +00:00
|
|
|
title: "Manu_Chao".to_string(),
|
|
|
|
};
|
2023-11-17 13:36:56 +00:00
|
|
|
let create_res: DbArticle = post(data.hostname_beta, "article", &create_form).await?;
|
2023-11-17 13:22:31 +00:00
|
|
|
assert_eq!(create_res.title, create_form.title);
|
2023-11-22 14:59:22 +00:00
|
|
|
assert!(create_res.local);
|
2023-11-17 13:22:31 +00:00
|
|
|
|
|
|
|
// article should be federated to alpha
|
2023-11-21 15:27:18 +00:00
|
|
|
let get_article = GetArticleData {
|
2023-11-17 13:22:31 +00:00
|
|
|
title: create_res.title.clone(),
|
|
|
|
};
|
|
|
|
let get_res =
|
2023-11-20 15:48:29 +00:00
|
|
|
get_query::<DbArticle, _>(data.hostname_alpha, "article", Some(get_article.clone()))
|
|
|
|
.await?;
|
2023-11-17 13:22:31 +00:00
|
|
|
assert_eq!(create_res.title, get_res.title);
|
2023-11-22 14:59:22 +00:00
|
|
|
assert_eq!(0, get_res.edits.len());
|
|
|
|
assert!(!get_res.local);
|
2023-11-17 13:22:31 +00:00
|
|
|
assert_eq!(create_res.text, get_res.text);
|
|
|
|
|
|
|
|
// edit the article
|
2023-11-21 15:27:18 +00:00
|
|
|
let edit_form = EditArticleData {
|
2023-11-17 13:22:31 +00:00
|
|
|
ap_id: create_res.ap_id,
|
|
|
|
new_text: "Lorem Ipsum 2".to_string(),
|
|
|
|
};
|
2023-11-17 13:36:56 +00:00
|
|
|
let edit_res: DbArticle = patch(data.hostname_beta, "article", &edit_form).await?;
|
2023-11-17 13:22:31 +00:00
|
|
|
assert_eq!(edit_res.text, edit_form.new_text);
|
2023-11-21 15:03:25 +00:00
|
|
|
assert_eq!(edit_res.edits.len(), 1);
|
2023-11-21 15:27:18 +00:00
|
|
|
assert!(edit_res.edits[0]
|
|
|
|
.id
|
|
|
|
.to_string()
|
|
|
|
.starts_with(&edit_res.ap_id.to_string()));
|
2023-11-17 13:22:31 +00:00
|
|
|
|
|
|
|
// edit should be federated to alpha
|
2023-11-21 15:27:18 +00:00
|
|
|
let get_article = GetArticleData {
|
2023-11-17 13:22:31 +00:00
|
|
|
title: edit_res.title.clone(),
|
|
|
|
};
|
|
|
|
let get_res =
|
2023-11-20 15:48:29 +00:00
|
|
|
get_query::<DbArticle, _>(data.hostname_alpha, "article", Some(get_article.clone()))
|
|
|
|
.await?;
|
2023-11-17 13:22:31 +00:00
|
|
|
assert_eq!(edit_res.title, get_res.title);
|
2023-11-22 14:59:22 +00:00
|
|
|
assert_eq!(edit_res.edits.len(), 1);
|
|
|
|
assert_eq!(edit_res.text, get_res.text);
|
|
|
|
|
|
|
|
data.stop()
|
|
|
|
}
|
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
#[serial]
|
|
|
|
async fn test_edit_remote_article() -> MyResult<()> {
|
|
|
|
let data = TestData::start();
|
|
|
|
|
|
|
|
follow_instance(data.hostname_alpha, data.hostname_beta).await?;
|
|
|
|
follow_instance(data.hostname_gamma, data.hostname_beta).await?;
|
|
|
|
|
|
|
|
// create new article
|
|
|
|
let create_form = CreateArticleData {
|
|
|
|
title: "Manu_Chao".to_string(),
|
|
|
|
};
|
|
|
|
let create_res: DbArticle = post(data.hostname_beta, "article", &create_form).await?;
|
|
|
|
assert_eq!(create_res.title, create_form.title);
|
|
|
|
assert!(create_res.local);
|
|
|
|
|
|
|
|
// article should be federated to alpha and gamma
|
|
|
|
let get_article = GetArticleData {
|
|
|
|
title: create_res.title.clone(),
|
|
|
|
};
|
|
|
|
let get_res =
|
|
|
|
get_query::<DbArticle, _>(data.hostname_alpha, "article", Some(get_article.clone()))
|
|
|
|
.await?;
|
|
|
|
assert_eq!(create_res.title, get_res.title);
|
|
|
|
assert_eq!(0, get_res.edits.len());
|
|
|
|
assert!(!get_res.local);
|
|
|
|
assert_eq!(create_res.text, get_res.text);
|
|
|
|
|
|
|
|
let get_res =
|
|
|
|
get_query::<DbArticle, _>(data.hostname_gamma, "article", Some(get_article.clone()))
|
|
|
|
.await?;
|
|
|
|
assert_eq!(create_res.title, get_res.title);
|
|
|
|
assert_eq!(create_res.text, get_res.text);
|
|
|
|
|
|
|
|
let edit_form = EditArticleData {
|
|
|
|
ap_id: create_res.ap_id,
|
|
|
|
new_text: "Lorem Ipsum 2".to_string(),
|
|
|
|
};
|
|
|
|
let edit_res: DbArticle = patch(data.hostname_alpha, "article", &edit_form).await?;
|
|
|
|
assert_eq!(edit_res.text, edit_form.new_text);
|
|
|
|
assert_eq!(edit_res.edits.len(), 1);
|
|
|
|
assert!(!edit_res.local);
|
|
|
|
assert!(edit_res.edits[0]
|
|
|
|
.id
|
|
|
|
.to_string()
|
|
|
|
.starts_with(&edit_res.ap_id.to_string()));
|
|
|
|
|
|
|
|
// edit should be federated to beta and gamma
|
|
|
|
let get_article = GetArticleData {
|
|
|
|
title: edit_res.title.clone(),
|
|
|
|
};
|
|
|
|
let get_res =
|
|
|
|
get_query::<DbArticle, _>(data.hostname_beta, "article", Some(get_article.clone())).await?;
|
|
|
|
assert_eq!(edit_res.title, get_res.title);
|
|
|
|
assert_eq!(edit_res.edits.len(), 1);
|
|
|
|
assert_eq!(edit_res.text, get_res.text);
|
|
|
|
|
|
|
|
let get_res =
|
|
|
|
get_query::<DbArticle, _>(data.hostname_gamma, "article", Some(get_article.clone()))
|
|
|
|
.await?;
|
|
|
|
assert_eq!(edit_res.title, get_res.title);
|
|
|
|
assert_eq!(edit_res.edits.len(), 1);
|
2023-11-17 13:22:31 +00:00
|
|
|
assert_eq!(edit_res.text, get_res.text);
|
|
|
|
|
2023-11-17 13:36:56 +00:00
|
|
|
data.stop()
|
2023-11-17 13:22:31 +00:00
|
|
|
}
|