2023-11-15 12:05:07 +00:00
|
|
|
extern crate fediwiki;
|
2023-11-16 09:25:54 +00:00
|
|
|
|
2023-11-16 12:38:41 +00:00
|
|
|
use fediwiki::api::{CreateArticle, FollowInstance, GetArticle, 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;
|
2023-11-15 12:05:07 +00:00
|
|
|
use fediwiki::start;
|
2023-11-16 11:48:57 +00:00
|
|
|
use once_cell::sync::Lazy;
|
|
|
|
use reqwest::Client;
|
2023-11-16 12:01:42 +00:00
|
|
|
use serde::{Deserialize, Serialize};
|
2023-11-16 11:48:57 +00:00
|
|
|
use serial_test::serial;
|
|
|
|
use std::sync::Once;
|
|
|
|
use tracing::log::LevelFilter;
|
|
|
|
use url::Url;
|
|
|
|
|
|
|
|
fn setup() {
|
|
|
|
static INIT: Once = Once::new();
|
|
|
|
INIT.call_once(|| {
|
|
|
|
env_logger::builder()
|
|
|
|
.filter_level(LevelFilter::Warn)
|
|
|
|
.filter_module("activitypub_federation", LevelFilter::Info)
|
|
|
|
.filter_module("fediwiki", LevelFilter::Info)
|
|
|
|
.init();
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
|
|
|
static CLIENT: Lazy<Client> = Lazy::new(|| Client::new());
|
2023-11-15 12:05:07 +00:00
|
|
|
|
|
|
|
#[tokio::test]
|
2023-11-16 11:48:57 +00:00
|
|
|
#[serial]
|
2023-11-16 12:38:41 +00:00
|
|
|
async fn test_create_and_read_article() -> MyResult<()> {
|
2023-11-16 11:48:57 +00:00
|
|
|
setup();
|
2023-11-15 12:05:07 +00:00
|
|
|
let hostname = "localhost:8131";
|
2023-11-15 14:07:02 +00:00
|
|
|
let handle = tokio::task::spawn(async {
|
2023-11-15 12:05:07 +00:00
|
|
|
start(hostname).await.unwrap();
|
|
|
|
});
|
|
|
|
|
2023-11-16 12:38:41 +00:00
|
|
|
// error on nonexistent article
|
|
|
|
let get_article = GetArticle {
|
|
|
|
title: "Manu_Chao".to_string(),
|
|
|
|
};
|
|
|
|
let not_found =
|
|
|
|
get_query::<DbArticle, _>(hostname, &format!("article"), Some(get_article.clone())).await;
|
|
|
|
assert!(not_found.is_err());
|
|
|
|
|
|
|
|
// create article
|
|
|
|
let create_article = CreateArticle {
|
|
|
|
title: get_article.title.to_string(),
|
|
|
|
text: "Lorem ipsum".to_string(),
|
|
|
|
};
|
|
|
|
let create_res: DbArticle = post(hostname, "article", &create_article).await?;
|
|
|
|
assert_eq!(create_article.title, create_res.title);
|
|
|
|
assert!(create_res.local);
|
|
|
|
|
|
|
|
// now article can be read
|
|
|
|
let get_res: DbArticle =
|
|
|
|
get_query(hostname, &format!("article"), Some(get_article.clone())).await?;
|
|
|
|
assert_eq!(create_article.title, get_res.title);
|
|
|
|
assert_eq!(create_article.text, get_res.text);
|
|
|
|
assert!(get_res.local);
|
|
|
|
|
2023-11-15 14:07:02 +00:00
|
|
|
handle.abort();
|
2023-11-16 09:25:54 +00:00
|
|
|
Ok(())
|
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-16 11:48:57 +00:00
|
|
|
setup();
|
2023-11-15 14:07:02 +00:00
|
|
|
let hostname_alpha = "localhost:8131";
|
|
|
|
let hostname_beta = "localhost:8132";
|
|
|
|
let handle_alpha = tokio::task::spawn(async {
|
|
|
|
start(hostname_alpha).await.unwrap();
|
|
|
|
});
|
|
|
|
let handle_beta = tokio::task::spawn(async {
|
|
|
|
start(hostname_beta).await.unwrap();
|
|
|
|
});
|
|
|
|
|
2023-11-16 11:48:57 +00:00
|
|
|
// check initial state
|
2023-11-16 12:01:42 +00:00
|
|
|
let alpha_instance: DbInstance = get(hostname_alpha, "instance").await?;
|
2023-11-16 11:48:57 +00:00
|
|
|
assert_eq!(0, alpha_instance.follows.len());
|
2023-11-16 12:01:42 +00:00
|
|
|
let beta_instance: DbInstance = get(hostname_beta, "instance").await?;
|
2023-11-16 11:48:57 +00:00
|
|
|
assert_eq!(0, beta_instance.followers.len());
|
|
|
|
|
|
|
|
// fetch beta instance on alpha
|
|
|
|
let resolve_object = ResolveObject {
|
|
|
|
id: Url::parse(&format!("http://{hostname_beta}"))?,
|
|
|
|
};
|
2023-11-16 12:01:42 +00:00
|
|
|
let beta_instance_resolved: DbInstance =
|
|
|
|
get_query(hostname_beta, "resolve_object", Some(resolve_object)).await?;
|
2023-11-16 11:48:57 +00:00
|
|
|
|
|
|
|
// send follow
|
|
|
|
let follow_instance = FollowInstance {
|
|
|
|
instance_id: beta_instance_resolved.ap_id,
|
|
|
|
};
|
2023-11-16 12:38:41 +00:00
|
|
|
// cant use post helper because follow doesnt return json
|
2023-11-16 11:48:57 +00:00
|
|
|
CLIENT
|
|
|
|
.post(format!("http://{hostname_alpha}/api/v1/instance/follow"))
|
|
|
|
.form(&follow_instance)
|
|
|
|
.send()
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
// check that follow was federated
|
2023-11-16 12:01:42 +00:00
|
|
|
let beta_instance: DbInstance = get(hostname_beta, "instance").await?;
|
2023-11-16 11:48:57 +00:00
|
|
|
assert_eq!(1, beta_instance.followers.len());
|
|
|
|
|
2023-11-16 12:01:42 +00:00
|
|
|
let alpha_instance: DbInstance = get(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-15 14:07:02 +00:00
|
|
|
handle_alpha.abort();
|
|
|
|
handle_beta.abort();
|
2023-11-16 09:25:54 +00:00
|
|
|
Ok(())
|
|
|
|
}
|
2023-11-16 12:01:42 +00:00
|
|
|
|
|
|
|
async fn get<T>(hostname: &str, endpoint: &str) -> MyResult<T>
|
|
|
|
where
|
|
|
|
T: for<'de> Deserialize<'de>,
|
|
|
|
{
|
|
|
|
get_query(hostname, endpoint, None::<i32>).await
|
|
|
|
}
|
|
|
|
|
|
|
|
async fn get_query<T, R>(hostname: &str, endpoint: &str, query: Option<R>) -> MyResult<T>
|
|
|
|
where
|
|
|
|
T: for<'de> Deserialize<'de>,
|
|
|
|
R: Serialize,
|
|
|
|
{
|
|
|
|
let mut res = CLIENT.get(format!("http://{}/api/v1/{}", hostname, endpoint));
|
|
|
|
if let Some(query) = query {
|
|
|
|
res = res.query(&query);
|
|
|
|
}
|
|
|
|
let alpha_instance: T = res.send().await?.json().await?;
|
|
|
|
Ok(alpha_instance)
|
|
|
|
}
|
2023-11-16 12:38:41 +00:00
|
|
|
|
|
|
|
async fn post<T: Serialize, R>(hostname: &str, endpoint: &str, form: &T) -> MyResult<R>
|
|
|
|
where
|
|
|
|
R: for<'de> Deserialize<'de>,
|
|
|
|
{
|
|
|
|
Ok(CLIENT
|
|
|
|
.post(format!("http://{}/api/v1/{}", hostname, endpoint))
|
|
|
|
.form(form)
|
|
|
|
.send()
|
|
|
|
.await?
|
|
|
|
.json()
|
|
|
|
.await?)
|
|
|
|
}
|