update tests to new api
This commit is contained in:
Cyborus
parent
cfd12a6306
commit
6d2c1ce21c
255
tests/ci_test.rs
255
tests/ci_test.rs
|
|
@ -1,5 +1,5 @@
|
|||
use eyre::{ensure, eyre, WrapErr};
|
||||
use forgejo_api::Forgejo;
|
||||
use forgejo_api::{Forgejo, structs::*};
|
||||
|
||||
#[tokio::test]
|
||||
async fn ci() -> eyre::Result<()> {
|
||||
|
|
@ -32,27 +32,29 @@ async fn ci() -> eyre::Result<()> {
|
|||
Ok(())
|
||||
}
|
||||
|
||||
async fn user(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
|
||||
let myself = api.myself().await?;
|
||||
ensure!(myself.is_admin, "user should be admin");
|
||||
async fn user(api: &Forgejo) -> eyre::Result<()> {
|
||||
let myself = api.user_get_current().await?;
|
||||
ensure!(myself.is_admin.unwrap(), "user should be admin");
|
||||
ensure!(
|
||||
myself.login == "TestingAdmin",
|
||||
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."))?;
|
||||
.user_get("TestingAdmin")
|
||||
.await?;
|
||||
ensure!(
|
||||
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?;
|
||||
ensure!(following == Vec::new(), "following list not empty");
|
||||
|
||||
let query = UserListFollowersQuery { page: None, limit: None };
|
||||
let followers = api.user_list_followers("TestingAdmin", query).await?;
|
||||
ensure!(followers == Vec::new(), "follower list not empty");
|
||||
|
||||
let url = url::Url::parse(&std::env::var("FORGEJO_API_CI_INSTANCE_URL")?)?;
|
||||
let password_api = Forgejo::new(
|
||||
|
|
@ -66,7 +68,7 @@ async fn user(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
|
|||
.wrap_err("failed to log in using username and password")?;
|
||||
|
||||
ensure!(
|
||||
api.myself().await? == password_api.myself().await?,
|
||||
api.user_get_current().await? == password_api.user_get_current().await?,
|
||||
"users not equal comparing token-auth and pass-auth"
|
||||
);
|
||||
|
||||
|
|
@ -94,32 +96,32 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
|
|||
let _ = git().args(["add", "."]).status()?;
|
||||
let _ = git().args(["commit", "-m", "initial commit"]).status()?;
|
||||
|
||||
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("default".into()),
|
||||
};
|
||||
let remote_repo = api.create_repo(repo_opt).await?;
|
||||
let remote_repo = api.create_current_user_repo(repo_opt).await?;
|
||||
ensure!(
|
||||
remote_repo.has_pull_requests,
|
||||
remote_repo.has_pull_requests.unwrap(),
|
||||
"repo does not accept pull requests"
|
||||
);
|
||||
ensure!(
|
||||
remote_repo.owner.login == "TestingAdmin",
|
||||
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\"");
|
||||
ensure!(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()
|
||||
|
|
@ -137,29 +139,29 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
|
|||
let _ = git().args(["commit", "-m", "egg"]).status()?;
|
||||
let _ = git().args(["push", "-u", "origin", "test"]).status()?;
|
||||
|
||||
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")?;
|
||||
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
|
||||
.wrap_err_with(|| eyre!("couldn't find unmerged pr {}", pr.number))?;
|
||||
.is_ok();
|
||||
ensure!(!is_merged, "pr should not yet be merged");
|
||||
let merge_opt = forgejo_api::MergePullRequestOption {
|
||||
act: forgejo_api::MergePrAction::Merge,
|
||||
let merge_opt = MergePullRequestOption {
|
||||
r#do: "merge".into(),
|
||||
merge_commit_id: None,
|
||||
merge_message_field: None,
|
||||
merge_title_field: None,
|
||||
|
|
@ -168,103 +170,106 @@ 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))?;
|
||||
.wrap_err_with(|| eyre!("couldn't merge pr {}", pr.number.unwrap()))?;
|
||||
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))?;
|
||||
.is_ok();
|
||||
ensure!(is_merged, "pr should be merged");
|
||||
let _ = git().args(["fetch"]).status()?;
|
||||
let _ = git().args(["pull"]).status()?;
|
||||
|
||||
let query = RepoListReleasesQuery {
|
||||
draft: None,
|
||||
pre_release: None,
|
||||
per_page: None,
|
||||
page: None,
|
||||
limit: None,
|
||||
};
|
||||
ensure!(
|
||||
api.get_releases("TestingAdmin", "test", forgejo_api::ReleaseQuery::default())
|
||||
api.repo_list_releases("TestingAdmin", "test", query)
|
||||
.await
|
||||
.wrap_err("releases list not found")?
|
||||
.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")?;
|
||||
|
||||
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 {
|
||||
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")?;
|
||||
|
||||
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")?;
|
||||
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");
|
||||
|
||||
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)
|
||||
&*api.download_release_attachment("TestingAdmin", "test", release.id.unwrap(), attachment.id.unwrap())
|
||||
.await?
|
||||
.as_deref()
|
||||
== Some(b"This is a file!"),
|
||||
== 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"
|
||||
);
|
||||
let _zip_archive = api.repo_get_archive("TestingAdmin", "test", "v1.0.zip")
|
||||
.await.unwrap();
|
||||
let _tar_archive = api.repo_get_archive("TestingAdmin", "test", "v1.0.tar.gz")
|
||||
.await.unwrap();
|
||||
// check these contents when their return value is fixed
|
||||
|
||||
api.delete_release_attachment("TestingAdmin", "test", release.id, attachment.id)
|
||||
api.repo_delete_release_attachment("TestingAdmin", "test", release.id.unwrap(), attachment.id.unwrap())
|
||||
.await
|
||||
.wrap_err("failed to deleted attachment")?;
|
||||
|
||||
api.delete_release("TestingAdmin", "test", release.id)
|
||||
api.repo_delete_release("TestingAdmin", "test", release.id.unwrap())
|
||||
.await
|
||||
.wrap_err("failed to delete release")?;
|
||||
|
||||
api.delete_tag("TestingAdmin", "test", "v1.0")
|
||||
api.repo_delete_tag("TestingAdmin", "test", "v1.0")
|
||||
.await
|
||||
.wrap_err("failed to delete release")?;
|
||||
|
||||
|
|
@ -272,124 +277,152 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
|
|||
}
|
||||
|
||||
async fn admin(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
|
||||
let user_opt = forgejo_api::CreateUserOption {
|
||||
let user_opt = CreateUserOption {
|
||||
created_at: None,
|
||||
email: "user@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")?;
|
||||
|
||||
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(),
|
||||
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!(
|
||||
users
|
||||
.iter()
|
||||
.find(|u| u.email == "user@noreply.example.org")
|
||||
.find(|u| u.email.as_ref().unwrap() == "user@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("public".into()),
|
||||
website: None,
|
||||
};
|
||||
let _ = api
|
||||
.admin_create_org("Pipis", org_opt)
|
||||
.await
|
||||
.wrap_err("failed to create org")?;
|
||||
let query = AdminGetAllOrgsQuery {
|
||||
page: None,
|
||||
limit: None,
|
||||
};
|
||||
ensure!(
|
||||
!api.admin_get_orgs(forgejo_api::AdminOrganizationQuery::default())
|
||||
!api.admin_get_all_orgs(query)
|
||||
.await?
|
||||
.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)
|
||||
api.admin_delete_user_public_key("Pipis", key.id.unwrap())
|
||||
.await
|
||||
.wrap_err("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)
|
||||
let query = AdminDeleteUserQuery {
|
||||
purge: Some(true),
|
||||
};
|
||||
api.admin_delete_user("Bepis", query)
|
||||
.await
|
||||
.wrap_err("failed to delete user")?;
|
||||
let query = AdminDeleteUserQuery {
|
||||
purge: Some(true),
|
||||
};
|
||||
ensure!(
|
||||
api.admin_delete_user("Ghost", true).await.is_err(),
|
||||
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)
|
||||
api.admin_cron_run(&crons.get(0).ok_or_else(|| eyre!("no crons"))?.name.as_ref().unwrap())
|
||||
.await
|
||||
.wrap_err("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: "forgejo".into(),
|
||||
};
|
||||
// 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 {
|
||||
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)
|
||||
api.admin_delete_hook(hook.id.unwrap())
|
||||
.await
|
||||
.wrap_err("failed to delete hook")?;
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue