rahix/forgejo-api
1
0
Fork 0
Code Activity

restructure tests

Browse source
This commit is contained in:
Cyborus 2024-01-18 17:16:52 -05:00
parent ac25339cf6
commit 83c236a02f
No known key found for this signature in database
1 changed files with 89 additions and 112 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

201
tests/ci_test.rs
View file

@ -1,48 +1,25 @@
use eyre::{ensure, eyre, WrapErr};
use forgejo_api::{structs::*, Forgejo}; use forgejo_api::{structs::*, Forgejo};
#[tokio::test] fn get_api() -> Forgejo {
async fn ci() -> eyre::Result<()> { let url = url::Url::parse(&std::env::var("FORGEJO_API_CI_INSTANCE_URL").unwrap()).unwrap();
let url = url::Url::parse(&std::env::var("FORGEJO_API_CI_INSTANCE_URL")?)?; let token = std::env::var("FORGEJO_API_CI_TOKEN").unwrap();
let token = std::env::var("FORGEJO_API_CI_TOKEN")?; Forgejo::new(forgejo_api::Auth::Token(&token), url).unwrap()
let api = Forgejo::new(forgejo_api::Auth::Token(&token), url)?;
let mut results = Vec::new();
results.push(user(&api).await.wrap_err("user error"));
results.push(repo(&api).await.wrap_err("repo error"));
results.push(admin(&api).await.wrap_err("admin error"));
let mut errors = 0;
for report in results.into_iter().filter_map(Result::err) {
errors += 1;
for (i, err) in report.chain().enumerate() {
println!("{i}. {err}");
if let Some(err) = err.downcast_ref::<forgejo_api::ForgejoError>() {
if let forgejo_api::ForgejoError::BadStructure(_, body) = err {
println!("BODY: {body}");
}
}
}
}
if errors > 0 {
eyre::bail!("test failed");
}
Ok(())
} }
async fn user(api: &Forgejo) -> eyre::Result<()> { #[tokio::test]
let myself = api.user_get_current().await?; async fn user() {
ensure!(myself.is_admin.unwrap(), "user should be admin"); let api = get_api();
ensure!(
myself.login.as_ref().unwrap() == "TestingAdmin", let myself = api.user_get_current().await.unwrap();
assert!(myself.is_admin.unwrap(), "user should be admin");
assert_eq!(
myself.login.as_ref().unwrap(), "TestingAdmin",
"user should be named \"TestingAdmin\"" "user should be named \"TestingAdmin\""
); );
let myself_indirect = api.user_get("TestingAdmin").await?; let myself_indirect = api.user_get("TestingAdmin").await.unwrap();
ensure!( assert_eq!(
myself == myself_indirect, myself, myself_indirect,
"result of `myself` does not match result of `get_user`" "result of `myself` does not match result of `get_user`"
); );
@ -50,17 +27,17 @@ async fn user(api: &Forgejo) -> eyre::Result<()> {
page: None, page: None,
limit: None, limit: None,
}; };
let following = api.user_list_following("TestingAdmin", query).await?; let following = api.user_list_following("TestingAdmin", query).await.unwrap();
ensure!(following == Vec::new(), "following list not empty"); assert_eq!(following, Vec::new(), "following list not empty");
let query = UserListFollowersQuery { let query = UserListFollowersQuery {
page: None, page: None,
limit: None, limit: None,
}; };
let followers = api.user_list_followers("TestingAdmin", query).await?; let followers = api.user_list_followers("TestingAdmin", query).await.unwrap();
ensure!(followers == Vec::new(), "follower list not empty"); assert_eq!(followers, Vec::new(), "follower list not empty");
let url = url::Url::parse(&std::env::var("FORGEJO_API_CI_INSTANCE_URL")?)?; let url = url::Url::parse(&std::env::var("FORGEJO_API_CI_INSTANCE_URL").unwrap()).unwrap();
let password_api = Forgejo::new( let password_api = Forgejo::new(
forgejo_api::Auth::Password { forgejo_api::Auth::Password {
username: "TestingAdmin", username: "TestingAdmin",
@ -69,18 +46,19 @@ async fn user(api: &Forgejo) -> eyre::Result<()> {
}, },
url, url,
) )
.wrap_err("failed to log in using username and password")?; .expect("failed to log in using username and password");
ensure!( assert!(
api.user_get_current().await? == password_api.user_get_current().await?, api.user_get_current().await.unwrap() == password_api.user_get_current().await.unwrap(),
"users not equal comparing token-auth and pass-auth" "users not equal comparing token-auth and pass-auth"
); );
Ok(())
} }
async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> { #[tokio::test]
tokio::fs::create_dir("/test_repo").await?; async fn repo() {
let api = get_api();
tokio::fs::create_dir("/test_repo").await.unwrap();
let git = || { let git = || {
let mut cmd = std::process::Command::new("git"); let mut cmd = std::process::Command::new("git");
cmd.current_dir("/test_repo"); cmd.current_dir("/test_repo");
@ -88,17 +66,17 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
}; };
let _ = git() let _ = git()
.args(["config", "--global", "init.defaultBranch", "main"]) .args(["config", "--global", "init.defaultBranch", "main"])
.status()?; .status().unwrap();
let _ = git().args(["init"]).status()?; let _ = git().args(["init"]).status().unwrap();
let _ = git() let _ = git()
.args(["config", "user.name", "TestingAdmin"]) .args(["config", "user.name", "TestingAdmin"])
.status()?; .status().unwrap();
let _ = git() let _ = git()
.args(["config", "user.email", "admin@noreply.example.org"]) .args(["config", "user.email", "admin@noreply.example.org"])
.status()?; .status().unwrap();
tokio::fs::write("/test_repo/README.md", "# Test\nThis is a test repo").await?; tokio::fs::write("/test_repo/README.md", "# Test\nThis is a test repo").await.unwrap();
let _ = git().args(["add", "."]).status()?; let _ = git().args(["add", "."]).status().unwrap();
let _ = git().args(["commit", "-m", "initial commit"]).status()?; let _ = git().args(["commit", "-m", "initial commit"]).status().unwrap();
let repo_opt = CreateRepoOption { let repo_opt = CreateRepoOption {
auto_init: Some(false), auto_init: Some(false),
@ -113,16 +91,16 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
template: Some(false), template: Some(false),
trust_model: Some("default".into()), trust_model: Some("default".into()),
}; };
let remote_repo = api.create_current_user_repo(repo_opt).await?; let remote_repo = api.create_current_user_repo(repo_opt).await.unwrap();
ensure!( assert!(
remote_repo.has_pull_requests.unwrap(), remote_repo.has_pull_requests.unwrap(),
"repo does not accept pull requests" "repo does not accept pull requests"
); );
ensure!( assert!(
remote_repo.owner.as_ref().unwrap().login.as_ref().unwrap() == "TestingAdmin", remote_repo.owner.as_ref().unwrap().login.as_ref().unwrap() == "TestingAdmin",
"repo owner is not \"TestingAdmin\"" "repo owner is not \"TestingAdmin\""
); );
ensure!( assert!(
remote_repo.name.as_ref().unwrap() == "test", remote_repo.name.as_ref().unwrap() == "test",
"repo owner is not \"test\"" "repo owner is not \"test\""
); );
@ -133,18 +111,18 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
remote_url.set_password(Some("password")).unwrap(); remote_url.set_password(Some("password")).unwrap();
let _ = git() let _ = git()
.args(["remote", "add", "origin", remote_url.as_str()]) .args(["remote", "add", "origin", remote_url.as_str()])
.status()?; .status().unwrap();
let _ = git().args(["push", "-u", "origin", "main"]).status()?; let _ = git().args(["push", "-u", "origin", "main"]).status().unwrap();
let _ = git().args(["switch", "-c", "test"]).status()?; let _ = git().args(["switch", "-c", "test"]).status().unwrap();
tokio::fs::write( tokio::fs::write(
"/test_repo/example.rs", "/test_repo/example.rs",
"fn add_one(x: u32) -> u32 { x + 1 }", "fn add_one(x: u32) -> u32 { x + 1 }",
) )
.await?; .await.unwrap();
let _ = git().args(["add", "."]).status()?; let _ = git().args(["add", "."]).status().unwrap();
let _ = git().args(["commit", "-m", "egg"]).status()?; let _ = git().args(["commit", "-m", "egg"]).status().unwrap();
let _ = git().args(["push", "-u", "origin", "test"]).status()?; let _ = git().args(["push", "-u", "origin", "test"]).status().unwrap();
let pr_opt = CreatePullRequestOption { let pr_opt = CreatePullRequestOption {
assignee: None, assignee: None,
@ -160,13 +138,13 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
let pr = api let pr = api
.repo_create_pull_request("TestingAdmin", "test", pr_opt) .repo_create_pull_request("TestingAdmin", "test", pr_opt)
.await .await
.wrap_err("couldn't create pr")?; .expect("couldn't create pr");
tokio::time::sleep(std::time::Duration::from_secs(3)).await; tokio::time::sleep(std::time::Duration::from_secs(3)).await;
let is_merged = api let is_merged = api
.repo_pull_request_is_merged("TestingAdmin", "test", pr.number.unwrap()) .repo_pull_request_is_merged("TestingAdmin", "test", pr.number.unwrap())
.await .await
.is_ok(); .is_ok();
ensure!(!is_merged, "pr should not yet be merged"); assert!(!is_merged, "pr should not yet be merged");
let merge_opt = MergePullRequestOption { let merge_opt = MergePullRequestOption {
r#do: "merge".into(), r#do: "merge".into(),
merge_commit_id: None, merge_commit_id: None,
@ -179,14 +157,14 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
}; };
api.repo_merge_pull_request("TestingAdmin", "test", pr.number.unwrap(), merge_opt) api.repo_merge_pull_request("TestingAdmin", "test", pr.number.unwrap(), merge_opt)
.await .await
.wrap_err_with(|| eyre!("couldn't merge pr {}", pr.number.unwrap()))?; .expect("couldn't merge pr");
let is_merged = api let is_merged = api
.repo_pull_request_is_merged("TestingAdmin", "test", pr.number.unwrap()) .repo_pull_request_is_merged("TestingAdmin", "test", pr.number.unwrap())
.await .await
.is_ok(); .is_ok();
ensure!(is_merged, "pr should be merged"); assert!(is_merged, "pr should be merged");
let _ = git().args(["fetch"]).status()?; let _ = git().args(["fetch"]).status().unwrap();
let _ = git().args(["pull"]).status()?; let _ = git().args(["pull"]).status().unwrap();
let query = RepoListReleasesQuery { let query = RepoListReleasesQuery {
draft: None, draft: None,
@ -195,10 +173,10 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
page: None, page: None,
limit: None, limit: None,
}; };
ensure!( assert!(
api.repo_list_releases("TestingAdmin", "test", query) api.repo_list_releases("TestingAdmin", "test", query)
.await .await
.wrap_err("releases list not found")? .unwrap()
.is_empty(), .is_empty(),
"there should be no releases yet" "there should be no releases yet"
); );
@ -210,7 +188,7 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
}; };
api.repo_create_tag("TestingAdmin", "test", tag_opt) api.repo_create_tag("TestingAdmin", "test", tag_opt)
.await .await
.wrap_err("failed to create tag")?; .expect("failed to create tag");
let release_opt = CreateReleaseOption { let release_opt = CreateReleaseOption {
body: Some("This is a release!".into()), body: Some("This is a release!".into()),
@ -223,7 +201,7 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
let release = api let release = api
.repo_create_release("TestingAdmin", "test", release_opt) .repo_create_release("TestingAdmin", "test", release_opt)
.await .await
.wrap_err("failed to create release")?; .expect("failed to create release");
let edit_release = EditReleaseOption { let edit_release = EditReleaseOption {
body: None, body: None,
draft: Some(false), draft: Some(false),
@ -234,17 +212,17 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
}; };
api.repo_edit_release("TestingAdmin", "test", release.id.unwrap(), edit_release) api.repo_edit_release("TestingAdmin", "test", release.id.unwrap(), edit_release)
.await .await
.wrap_err("failed to edit release")?; .expect("failed to edit release");
let release_by_tag = api let release_by_tag = api
.repo_get_release_by_tag("TestingAdmin", "test", "v1.0") .repo_get_release_by_tag("TestingAdmin", "test", "v1.0")
.await .await
.wrap_err("failed to find release")?; .expect("failed to find release");
let release_latest = api let release_latest = api
.repo_get_latest_release("TestingAdmin", "test") .repo_get_latest_release("TestingAdmin", "test")
.await .await
.wrap_err("failed to find latest release")?; .expect("failed to find latest release");
ensure!(release_by_tag == release_latest, "releases not equal"); assert!(release_by_tag == release_latest, "releases not equal");
let attachment = api let attachment = api
.repo_create_release_attachment( .repo_create_release_attachment(
@ -257,8 +235,8 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
}, },
) )
.await .await
.wrap_err("failed to create release attachment")?; .expect("failed to create release attachment");
ensure!( assert!(
&*api &*api
.download_release_attachment( .download_release_attachment(
"TestingAdmin", "TestingAdmin",
@ -266,7 +244,7 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
release.id.unwrap(), release.id.unwrap(),
attachment.id.unwrap() attachment.id.unwrap()
) )
.await? .await.unwrap()
== b"This is a file!", == b"This is a file!",
"couldn't download attachment" "couldn't download attachment"
); );
@ -287,20 +265,21 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
attachment.id.unwrap(), attachment.id.unwrap(),
) )
.await .await
.wrap_err("failed to deleted attachment")?; .expect("failed to deleted attachment");
api.repo_delete_release("TestingAdmin", "test", release.id.unwrap()) api.repo_delete_release("TestingAdmin", "test", release.id.unwrap())
.await .await
.wrap_err("failed to delete release")?; .expect("failed to delete release");
api.repo_delete_tag("TestingAdmin", "test", "v1.0") api.repo_delete_tag("TestingAdmin", "test", "v1.0")
.await .await
.wrap_err("failed to delete release")?; .expect("failed to delete release");
Ok(())
} }
async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> { #[tokio::test]
async fn admin() {
let api = get_api();
let user_opt = CreateUserOption { let user_opt = CreateUserOption {
created_at: None, created_at: None,
email: "user@noreply.example.org".into(), email: "user@noreply.example.org".into(),
@ -317,7 +296,7 @@ async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
let _ = api let _ = api
.admin_create_user(user_opt) .admin_create_user(user_opt)
.await .await
.wrap_err("failed to create user")?; .expect("failed to create user");
let query = AdminSearchUsersQuery { let query = AdminSearchUsersQuery {
source_id: None, source_id: None,
@ -328,8 +307,8 @@ async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
let users = api let users = api
.admin_search_users(query) .admin_search_users(query)
.await .await
.wrap_err("failed to search users")?; .expect("failed to search users");
ensure!( assert!(
users users
.iter() .iter()
.find(|u| u.login.as_ref().unwrap() == "Pipis") .find(|u| u.login.as_ref().unwrap() == "Pipis")
@ -343,8 +322,8 @@ async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
let users = api let users = api
.admin_get_all_emails(query) .admin_get_all_emails(query)
.await .await
.wrap_err("failed to search emails")?; .expect("failed to search emails");
ensure!( assert!(
users users
.iter() .iter()
.find(|u| u.email.as_ref().unwrap() == "user@noreply.example.org") .find(|u| u.email.as_ref().unwrap() == "user@noreply.example.org")
@ -365,13 +344,13 @@ async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
let _ = api let _ = api
.admin_create_org("Pipis", org_opt) .admin_create_org("Pipis", org_opt)
.await .await
.wrap_err("failed to create org")?; .expect("failed to create org");
let query = AdminGetAllOrgsQuery { let query = AdminGetAllOrgsQuery {
page: None, page: None,
limit: None, limit: None,
}; };
ensure!( assert!(
!api.admin_get_all_orgs(query).await?.is_empty(), !api.admin_get_all_orgs(query).await.unwrap().is_empty(),
"org list empty" "org list empty"
); );
@ -383,23 +362,23 @@ async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
let key = api let key = api
.admin_create_public_key("Pipis", key_opt) .admin_create_public_key("Pipis", key_opt)
.await .await
.wrap_err("failed to create key")?; .expect("failed to create key");
api.admin_delete_user_public_key("Pipis", key.id.unwrap()) api.admin_delete_user_public_key("Pipis", key.id.unwrap())
.await .await
.wrap_err("failed to delete key")?; .expect("failed to delete key");
let rename_opt = RenameUserOption { let rename_opt = RenameUserOption {
new_username: "Bepis".into(), new_username: "Bepis".into(),
}; };
api.admin_rename_user("Pipis", rename_opt) api.admin_rename_user("Pipis", rename_opt)
.await .await
.wrap_err("failed to rename user")?; .expect("failed to rename user");
let query = AdminDeleteUserQuery { purge: Some(true) }; let query = AdminDeleteUserQuery { purge: Some(true) };
api.admin_delete_user("Bepis", query) api.admin_delete_user("Bepis", query)
.await .await
.wrap_err("failed to delete user")?; .expect("failed to delete user");
let query = AdminDeleteUserQuery { purge: Some(true) }; let query = AdminDeleteUserQuery { purge: Some(true) };
ensure!( assert!(
api.admin_delete_user("Ghost", query).await.is_err(), api.admin_delete_user("Ghost", query).await.is_err(),
"deleting fake user should fail" "deleting fake user should fail"
); );
@ -411,17 +390,17 @@ async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
let crons = api let crons = api
.admin_cron_list(query) .admin_cron_list(query)
.await .await
.wrap_err("failed to get crons list")?; .expect("failed to get crons list");
api.admin_cron_run( api.admin_cron_run(
&crons &crons
.get(0) .get(0)
.ok_or_else(|| eyre!("no crons"))? .expect("no crons")
.name .name
.as_ref() .as_ref()
.unwrap(), .unwrap(),
) )
.await .await
.wrap_err("failed to run cron")?; .expect("failed to run cron");
let hook_opt = CreateHookOption { let hook_opt = CreateHookOption {
active: None, active: None,
@ -443,7 +422,7 @@ async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
let hook = api let hook = api
.admin_create_hook(hook_opt) .admin_create_hook(hook_opt)
.await .await
.wrap_err("failed to create hook")?; .expect("failed to create hook");
let edit_hook = EditHookOption { let edit_hook = EditHookOption {
active: Some(true), active: Some(true),
authorization_header: None, authorization_header: None,
@ -453,10 +432,8 @@ async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
}; };
api.admin_edit_hook(hook.id.unwrap(), edit_hook) api.admin_edit_hook(hook.id.unwrap(), edit_hook)
.await .await
.wrap_err("failed to edit hook")?; .expect("failed to edit hook");
api.admin_delete_hook(hook.id.unwrap()) api.admin_delete_hook(hook.id.unwrap())
.await .await
.wrap_err("failed to delete hook")?; .expect("failed to delete hook");
Ok(())
} }