diff options
Diffstat (limited to 'tests/ci_test.rs')
| -rw-r--r-- | tests/ci_test.rs | 501 |
1 files changed, 285 insertions, 216 deletions
diff --git a/tests/ci_test.rs b/tests/ci_test.rs index c7e3b90..c4d8a5d 100644 --- a/tests/ci_test.rs +++ b/tests/ci_test.rs @@ -1,60 +1,50 @@ -use eyre::{ensure, eyre, WrapErr}; -use forgejo_api::Forgejo; +use forgejo_api::{structs::*, Forgejo}; -#[tokio::test] -async fn ci() -> eyre::Result<()> { - let url = url::Url::parse(&std::env::var("FORGEJO_API_CI_INSTANCE_URL")?)?; - let token = std::env::var("FORGEJO_API_CI_TOKEN")?; - 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(()) +fn get_api() -> Forgejo { + let url = url::Url::parse(&std::env::var("FORGEJO_API_CI_INSTANCE_URL").unwrap()).unwrap(); + let token = std::env::var("FORGEJO_API_CI_TOKEN").unwrap(); + Forgejo::new(forgejo_api::Auth::Token(&token), url).unwrap() } -async fn user(api: &forgejo_api::Forgejo) -> eyre::Result<()> { - let myself = api.myself().await?; - ensure!(myself.is_admin, "user should be admin"); - ensure!( - myself.login == "TestingAdmin", +#[tokio::test] +async fn user() { + let api = get_api(); + + 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\"" ); - let myself_indirect = api - .get_user("TestingAdmin") - .await? - .ok_or_else(|| eyre!("\"TestingAdmin\" not found, but should have been."))?; - ensure!( - myself == myself_indirect, + let myself_indirect = api.user_get("TestingAdmin").await.unwrap(); + assert_eq!( + myself, myself_indirect, "result of `myself` does not match result of `get_user`" ); - let following = api.get_following("TestingAdmin").await?; - ensure!(following == Some(Vec::new()), "following list not empty"); - let followers = api.get_followers("TestingAdmin").await?; - ensure!(followers == Some(Vec::new()), "follower list not empty"); + let query = UserListFollowingQuery { + page: None, + limit: None, + }; + let following = api + .user_list_following("TestingAdmin", query) + .await + .unwrap(); + assert_eq!(following, Vec::new(), "following list not empty"); + + let query = UserListFollowersQuery { + page: None, + limit: None, + }; + let followers = api + .user_list_followers("TestingAdmin", query) + .await + .unwrap(); + 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( forgejo_api::Auth::Password { username: "TestingAdmin", @@ -63,103 +53,133 @@ async fn user(api: &forgejo_api::Forgejo) -> eyre::Result<()> { }, url, ) - .wrap_err("failed to log in using username and password")?; + .expect("failed to log in using username and password"); - ensure!( - api.myself().await? == password_api.myself().await?, + assert!( + api.user_get_current().await.unwrap() == password_api.user_get_current().await.unwrap(), "users not equal comparing token-auth and pass-auth" ); - - Ok(()) } -async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> { - tokio::fs::create_dir("/test_repo").await?; +#[tokio::test] +async fn repo() { + let api = get_api(); + + tokio::fs::create_dir("./test_repo").await.unwrap(); let git = || { let mut cmd = std::process::Command::new("git"); - cmd.current_dir("/test_repo"); + cmd.current_dir("./test_repo"); cmd }; let _ = git() .args(["config", "--global", "init.defaultBranch", "main"]) - .status()?; - let _ = git().args(["init"]).status()?; + .status() + .unwrap(); + let _ = git().args(["init"]).status().unwrap(); let _ = git() .args(["config", "user.name", "TestingAdmin"]) - .status()?; + .status() + .unwrap(); let _ = git() .args(["config", "user.email", "admin@noreply.example.org"]) - .status()?; - tokio::fs::write("/test_repo/README.md", "# Test\nThis is a test repo").await?; - let _ = git().args(["add", "."]).status()?; - let _ = git().args(["commit", "-m", "initial commit"]).status()?; + .status() + .unwrap(); + tokio::fs::write("./test_repo/README.md", "# Test\nThis is a test repo") + .await + .unwrap(); + let _ = git().args(["add", "."]).status().unwrap(); + let _ = git() + .args(["commit", "-m", "initial commit"]) + .status() + .unwrap(); - let repo_opt = forgejo_api::CreateRepoOption { - auto_init: false, - default_branch: "main".into(), + let repo_opt = CreateRepoOption { + auto_init: Some(false), + default_branch: Some("main".into()), description: Some("Test Repo".into()), - gitignores: "".into(), - issue_labels: "".into(), - license: "".into(), + gitignores: Some("".into()), + issue_labels: Some("".into()), + license: Some("".into()), name: "test".into(), - private: false, - readme: "".into(), - template: false, - trust_model: forgejo_api::TrustModel::Default, + private: Some(false), + readme: None, + template: Some(false), + trust_model: Some(CreateRepoOptionTrustModel::Default), }; - let remote_repo = api.create_repo(repo_opt).await?; - ensure!( - remote_repo.has_pull_requests, + let remote_repo = api.create_current_user_repo(repo_opt).await.unwrap(); + assert!( + remote_repo.has_pull_requests.unwrap(), "repo does not accept pull requests" ); - ensure!( - remote_repo.owner.login == "TestingAdmin", + assert!( + remote_repo.owner.as_ref().unwrap().login.as_ref().unwrap() == "TestingAdmin", "repo owner is not \"TestingAdmin\"" ); - ensure!(remote_repo.name == "test", "repo owner is not \"test\""); + assert!( + remote_repo.name.as_ref().unwrap() == "test", + "repo owner is not \"test\"" + ); tokio::time::sleep(std::time::Duration::from_secs(3)).await; - let mut remote_url = remote_repo.clone_url.clone(); + let mut remote_url = remote_repo.clone_url.clone().unwrap(); remote_url.set_username("TestingAdmin").unwrap(); remote_url.set_password(Some("password")).unwrap(); let _ = git() .args(["remote", "add", "origin", remote_url.as_str()]) - .status()?; - let _ = git().args(["push", "-u", "origin", "main"]).status()?; + .status() + .unwrap(); + 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( - "/test_repo/example.rs", + "./test_repo/example.rs", "fn add_one(x: u32) -> u32 { x + 1 }", ) - .await?; - let _ = git().args(["add", "."]).status()?; - let _ = git().args(["commit", "-m", "egg"]).status()?; - let _ = git().args(["push", "-u", "origin", "test"]).status()?; + .await + .unwrap(); + let _ = git().args(["add", "."]).status().unwrap(); + let _ = git().args(["commit", "-m", "egg"]).status().unwrap(); + let _ = git() + .args(["push", "-u", "origin", "test"]) + .status() + .unwrap(); - let pr_opt = forgejo_api::CreatePullRequestOption { + let pr_opt = CreatePullRequestOption { assignee: None, - assignees: vec!["TestingAdmin".into()], - base: "main".into(), - body: "This is a test PR".into(), + assignees: Some(vec!["TestingAdmin".into()]), + base: Some("main".into()), + body: Some("This is a test PR".into()), due_date: None, - head: "test".into(), - labels: Vec::new(), + head: Some("test".into()), + labels: None, milestone: None, - title: "test pr".into(), + title: Some("test pr".into()), }; let pr = api - .create_pr("TestingAdmin", "test", pr_opt) + .repo_create_pull_request("TestingAdmin", "test", pr_opt) .await - .wrap_err("couldn't create pr")?; + .expect("couldn't create pr"); tokio::time::sleep(std::time::Duration::from_secs(3)).await; let is_merged = api - .is_merged("TestingAdmin", "test", pr.number) + .repo_pull_request_is_merged("TestingAdmin", "test", pr.number.unwrap()) + .await + .is_ok(); + assert!(!is_merged, "pr should not yet be merged"); + let pr_files_query = RepoGetPullRequestFilesQuery { + skip_to: None, + whitespace: None, + page: None, + limit: None, + }; + let (_, _) = api + .repo_get_pull_request_files("TestingAdmin", "test", pr.number.unwrap(), pr_files_query) .await - .wrap_err_with(|| eyre!("couldn't find unmerged pr {}", pr.number))?; - ensure!(!is_merged, "pr should not yet be merged"); - let merge_opt = forgejo_api::MergePullRequestOption { - act: forgejo_api::MergePrAction::Merge, + .unwrap(); + let merge_opt = MergePullRequestOption { + r#do: MergePullRequestOptionDo::Merge, merge_commit_id: None, merge_message_field: None, merge_title_field: None, @@ -168,230 +188,279 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> { head_commit_id: None, merge_when_checks_succeed: None, }; - api.merge_pr("TestingAdmin", "test", pr.number, merge_opt) + api.repo_merge_pull_request("TestingAdmin", "test", pr.number.unwrap(), merge_opt) .await - .wrap_err_with(|| eyre!("couldn't merge pr {}", pr.number))?; + .expect("couldn't merge pr"); let is_merged = api - .is_merged("TestingAdmin", "test", pr.number) + .repo_pull_request_is_merged("TestingAdmin", "test", pr.number.unwrap()) .await - .wrap_err_with(|| eyre!("couldn't find merged pr {}", pr.number))?; - ensure!(is_merged, "pr should be merged"); - let _ = git().args(["fetch"]).status()?; - let _ = git().args(["pull"]).status()?; - - ensure!( - api.get_releases("TestingAdmin", "test", forgejo_api::ReleaseQuery::default()) + .is_ok(); + assert!(is_merged, "pr should be merged"); + let _ = git().args(["fetch"]).status().unwrap(); + let _ = git().args(["pull"]).status().unwrap(); + + let query = RepoListReleasesQuery { + draft: None, + pre_release: None, + per_page: None, + page: None, + limit: None, + }; + assert!( + api.repo_list_releases("TestingAdmin", "test", query) .await - .wrap_err("releases list not found")? + .unwrap() .is_empty(), "there should be no releases yet" ); - let tag_opt = forgejo_api::CreateTagOption { + let tag_opt = CreateTagOption { message: Some("This is a tag!".into()), tag_name: "v1.0".into(), target: None, }; - api.create_tag("TestingAdmin", "test", tag_opt) + api.repo_create_tag("TestingAdmin", "test", tag_opt) .await - .wrap_err("failed to create tag")?; + .expect("failed to create tag"); - let release_opt = forgejo_api::CreateReleaseOption { - body: "This is a release!".into(), - draft: true, - name: "v1.0".into(), - prerelease: false, + let release_opt = CreateReleaseOption { + body: Some("This is a release!".into()), + draft: Some(true), + name: Some("v1.0".into()), + prerelease: Some(false), tag_name: "v1.0".into(), target_commitish: None, }; let release = api - .create_release("TestingAdmin", "test", release_opt) + .repo_create_release("TestingAdmin", "test", release_opt) .await - .wrap_err("failed to create release")?; - let edit_release = forgejo_api::EditReleaseOption { + .expect("failed to create release"); + let edit_release = EditReleaseOption { + body: None, draft: Some(false), - ..Default::default() + name: None, + prerelease: None, + tag_name: None, + target_commitish: None, }; - api.edit_release("TestingAdmin", "test", release.id, edit_release) + api.repo_edit_release("TestingAdmin", "test", release.id.unwrap(), edit_release) .await - .wrap_err("failed to edit release")?; + .expect("failed to edit release"); let release_by_tag = api - .get_release_by_tag("TestingAdmin", "test", "v1.0") + .repo_get_release_by_tag("TestingAdmin", "test", "v1.0") .await - .wrap_err("failed to find release")?; + .expect("failed to find release"); let release_latest = api - .latest_release("TestingAdmin", "test") + .repo_get_latest_release("TestingAdmin", "test") .await - .wrap_err("failed to find latest release")?; - ensure!(release_by_tag == release_latest, "releases not equal"); + .expect("failed to find latest release"); + assert!(release_by_tag == release_latest, "releases not equal"); let attachment = api - .create_release_attachment( + .repo_create_release_attachment( "TestingAdmin", "test", - release.id, - "test.txt", + release.id.unwrap(), b"This is a file!".to_vec(), + RepoCreateReleaseAttachmentQuery { + name: Some("test.txt".into()), + }, ) .await - .wrap_err("failed to create release attachment")?; - ensure!( - api.download_release_attachment("TestingAdmin", "test", release.id, attachment.id) - .await? - .as_deref() - == Some(b"This is a file!"), + .expect("failed to create release attachment"); + assert!( + &*api + .download_release_attachment( + "TestingAdmin", + "test", + release.id.unwrap(), + attachment.id.unwrap() + ) + .await + .unwrap() + == b"This is a file!", "couldn't download attachment" ); - ensure!( - api.download_zip_archive("TestingAdmin", "test", "v1.0") - .await? - .is_some(), - "couldn't download zip archive" - ); - ensure!( - api.download_tarball_archive("TestingAdmin", "test", "v1.0") - .await? - .is_some(), - "couldn't download tape archive" - ); - - api.delete_release_attachment("TestingAdmin", "test", release.id, attachment.id) + let _zip_archive = api + .repo_get_archive("TestingAdmin", "test", "v1.0.zip") .await - .wrap_err("failed to deleted attachment")?; - - api.delete_release("TestingAdmin", "test", release.id) + .unwrap(); + let _tar_archive = api + .repo_get_archive("TestingAdmin", "test", "v1.0.tar.gz") .await - .wrap_err("failed to delete release")?; + .unwrap(); + // check these contents when their return value is fixed + + api.repo_delete_release_attachment( + "TestingAdmin", + "test", + release.id.unwrap(), + attachment.id.unwrap(), + ) + .await + .expect("failed to deleted attachment"); - api.delete_tag("TestingAdmin", "test", "v1.0") + api.repo_delete_release("TestingAdmin", "test", release.id.unwrap()) .await - .wrap_err("failed to delete release")?; + .expect("failed to delete release"); - Ok(()) + api.repo_delete_tag("TestingAdmin", "test", "v1.0") + .await + .expect("failed to delete release"); } -async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> { - let user_opt = forgejo_api::CreateUserOption { +#[tokio::test] +async fn admin() { + let api = get_api(); + + let user_opt = CreateUserOption { created_at: None, - email: "user@noreply.example.org".into(), + email: "pipis@noreply.example.org".into(), full_name: None, login_name: None, - must_change_password: false, - password: "userpass".into(), - restricted: false, - send_notify: true, + must_change_password: None, + password: Some("userpass".into()), + restricted: Some(false), + send_notify: Some(true), source_id: None, username: "Pipis".into(), - visibility: "public".into(), + visibility: Some("public".into()), }; let _ = api .admin_create_user(user_opt) .await - .wrap_err("failed to create user")?; + .expect("failed to create user"); + let query = AdminSearchUsersQuery { + source_id: None, + login_name: None, + page: None, + limit: None, + }; let users = api - .admin_users(forgejo_api::AdminUserQuery::default()) + .admin_search_users(query) .await - .wrap_err("failed to search users")?; - ensure!( - users.iter().find(|u| u.login == "Pipis").is_some(), + .expect("failed to search users"); + assert!( + users + .iter() + .find(|u| u.login.as_ref().unwrap() == "Pipis") + .is_some(), "could not find new user" ); + let query = AdminGetAllEmailsQuery { + page: None, + limit: None, + }; let users = api - .admin_get_emails(forgejo_api::EmailListQuery::default()) + .admin_get_all_emails(query) .await - .wrap_err("failed to search emails")?; - ensure!( + .expect("failed to search emails"); + assert!( users .iter() - .find(|u| u.email == "user@noreply.example.org") + .find(|u| u.email.as_ref().unwrap() == "pipis@noreply.example.org") .is_some(), "could not find new user" ); - let org_opt = forgejo_api::CreateOrgOption { + let org_opt = CreateOrgOption { description: None, + email: None, full_name: None, location: None, repo_admin_change_team_access: None, username: "test-org".into(), - visibility: forgejo_api::OrgVisibility::Public, + visibility: Some(CreateOrgOptionVisibility::Public), website: None, }; let _ = api .admin_create_org("Pipis", org_opt) .await - .wrap_err("failed to create org")?; - ensure!( - !api.admin_get_orgs(forgejo_api::AdminOrganizationQuery::default()) - .await? - .is_empty(), + .expect("failed to create org"); + let query = AdminGetAllOrgsQuery { + page: None, + limit: None, + }; + assert!( + !api.admin_get_all_orgs(query).await.unwrap().is_empty(), "org list empty" ); - let key_opt = forgejo_api::CreateKeyOption { + let key_opt = CreateKeyOption { key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIN68ehQAsbGEwlXPa2AxbAh1QxFQrtRel2jeC0hRlPc1 user@noreply.example.org".into(), read_only: None, title: "Example Key".into(), }; let key = api - .admin_add_key("Pipis", key_opt) + .admin_create_public_key("Pipis", key_opt) .await - .wrap_err("failed to create key")?; - api.admin_delete_key("Pipis", key.id) + .expect("failed to create key"); + api.admin_delete_user_public_key("Pipis", key.id.unwrap()) .await - .wrap_err("failed to delete key")?; + .expect("failed to delete key"); - let rename_opt = forgejo_api::RenameUserOption { + let rename_opt = RenameUserOption { new_username: "Bepis".into(), }; api.admin_rename_user("Pipis", rename_opt) .await - .wrap_err("failed to rename user")?; - api.admin_delete_user("Bepis", true) + .expect("failed to rename user"); + let query = AdminDeleteUserQuery { purge: Some(true) }; + api.admin_delete_user("Bepis", query) .await - .wrap_err("failed to delete user")?; - ensure!( - api.admin_delete_user("Ghost", true).await.is_err(), + .expect("failed to delete user"); + let query = AdminDeleteUserQuery { purge: Some(true) }; + assert!( + api.admin_delete_user("Ghost", query).await.is_err(), "deleting fake user should fail" ); + let query = AdminCronListQuery { + page: None, + limit: None, + }; let crons = api - .admin_get_crons(forgejo_api::CronQuery::default()) + .admin_cron_list(query) .await - .wrap_err("failed to get crons list")?; - api.admin_run_cron(&crons.get(0).ok_or_else(|| eyre!("no crons"))?.name) + .expect("failed to get crons list"); + api.admin_cron_run(&crons.get(0).expect("no crons").name.as_ref().unwrap()) .await - .wrap_err("failed to run cron")?; + .expect("failed to run cron"); - let hook_opt = forgejo_api::CreateHookOption { + let hook_opt = CreateHookOption { active: None, authorization_header: None, branch_filter: None, - config: forgejo_api::CreateHookOptionConfig { - content_type: "json".into(), - url: url::Url::parse("http://test.local/").unwrap(), - other: Default::default(), + config: CreateHookOptionConfig { + // content_type: "json".into(), + // url: url::Url::parse("http://test.local/").unwrap(), + additional: [ + ("content_type".into(), "json".into()), + ("url".into(), "http://test.local/".into()), + ] + .into(), }, - events: Vec::new(), - _type: forgejo_api::HookType::Forgejo, + events: Some(Vec::new()), + r#type: CreateHookOptionType::Gitea, }; // yarr har har me matey this is me hook let hook = api .admin_create_hook(hook_opt) .await - .wrap_err("failed to create hook")?; - let edit_hook = forgejo_api::EditHookOption { + .expect("failed to create hook"); + let edit_hook = EditHookOption { active: Some(true), - ..Default::default() + authorization_header: None, + branch_filter: None, + config: None, + events: None, }; - api.admin_edit_hook(hook.id, edit_hook) + api.admin_edit_hook(hook.id.unwrap(), edit_hook) .await - .wrap_err("failed to edit hook")?; - api.admin_delete_hook(hook.id) + .expect("failed to edit hook"); + api.admin_delete_hook(hook.id.unwrap()) .await - .wrap_err("failed to delete hook")?; - - Ok(()) + .expect("failed to delete hook"); } |