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-24 14:31:31 +00:00
|
|
|
use crate::common::{edit_article, follow_instance, get_query, 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(),
|
|
|
|
};
|
2023-11-24 14:31:31 +00:00
|
|
|
let edit_res = edit_article(data.hostname_alpha, &create_res.title, &edit_form).await?;
|
2023-11-22 14:59:22 +00:00
|
|
|
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-22 15:41:34 +00:00
|
|
|
get_query::<DbInstance, _>(data.hostname_beta, "resolve_instance", 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-24 14:31:31 +00:00
|
|
|
let edit_res = edit_article(data.hostname_beta, &create_res.title, &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);
|
|
|
|
|
|
|
|
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(),
|
|
|
|
};
|
2023-11-24 14:31:31 +00:00
|
|
|
let edit_res = edit_article(data.hostname_alpha, &create_res.title, &edit_form).await?;
|
2023-11-22 14:59:22 +00:00
|
|
|
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
|
|
|
}
|
2023-11-22 15:41:34 +00:00
|
|
|
|
|
|
|
#[tokio::test]
|
|
|
|
#[serial]
|
|
|
|
async fn test_edit_conflict() -> MyResult<()> {
|
|
|
|
let data = TestData::start();
|
|
|
|
|
|
|
|
follow_instance(data.hostname_alpha, 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);
|
|
|
|
|
2023-11-24 14:31:31 +00:00
|
|
|
// fetch article to gamma
|
|
|
|
let resolve_object = ResolveObject {
|
|
|
|
id: create_res.ap_id.inner().clone(),
|
|
|
|
};
|
|
|
|
let resolve_res: DbArticle =
|
|
|
|
get_query(data.hostname_gamma, "resolve_article", Some(resolve_object)).await?;
|
|
|
|
assert_eq!(create_res.text, resolve_res.text);
|
|
|
|
|
2023-11-22 15:41:34 +00:00
|
|
|
// alpha edits article
|
|
|
|
let edit_form = EditArticleData {
|
|
|
|
ap_id: create_res.ap_id.clone(),
|
|
|
|
new_text: "Lorem Ipsum".to_string(),
|
|
|
|
};
|
2023-11-24 14:31:31 +00:00
|
|
|
let edit_res = edit_article(data.hostname_alpha, &create_res.title, &edit_form).await?;
|
2023-11-22 15:41:34 +00:00
|
|
|
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()));
|
|
|
|
|
|
|
|
// gamma also edits, as its not the latest version there is a conflict
|
|
|
|
let edit_form = EditArticleData {
|
|
|
|
ap_id: create_res.ap_id,
|
2023-11-24 14:31:31 +00:00
|
|
|
new_text: "aaaa".to_string(),
|
2023-11-22 15:41:34 +00:00
|
|
|
};
|
2023-11-24 14:31:31 +00:00
|
|
|
let edit_res = edit_article(data.hostname_gamma, &create_res.title, &edit_form).await?;
|
|
|
|
assert_eq!(create_res.text, edit_res.text);
|
|
|
|
assert_eq!(0, edit_res.edits.len());
|
2023-11-22 15:41:34 +00:00
|
|
|
assert!(!edit_res.local);
|
|
|
|
|
|
|
|
data.stop()
|
|
|
|
}
|