278 lines
8 KiB
Rust
278 lines
8 KiB
Rust
use forgejo_api::structs::*;
|
|
|
|
mod common;
|
|
|
|
#[tokio::test]
|
|
async fn user() {
|
|
let api = common::login();
|
|
|
|
let user_opt = CreateUserOption {
|
|
created_at: None,
|
|
email: "pipis@noreply.example.org".into(),
|
|
full_name: None,
|
|
login_name: None,
|
|
must_change_password: None,
|
|
password: Some("userpass".into()),
|
|
restricted: Some(false),
|
|
send_notify: Some(true),
|
|
source_id: None,
|
|
username: "Pipis".into(),
|
|
visibility: Some("public".into()),
|
|
};
|
|
let _ = api
|
|
.admin_create_user(user_opt)
|
|
.await
|
|
.expect("failed to create user");
|
|
|
|
let query = AdminSearchUsersQuery::default();
|
|
let users = api
|
|
.admin_search_users(query)
|
|
.await
|
|
.expect("failed to search users");
|
|
assert!(
|
|
users.iter().any(|u| u.login.as_ref().unwrap() == "Pipis"),
|
|
"could not find new user"
|
|
);
|
|
let query = AdminGetAllEmailsQuery::default();
|
|
let users = api
|
|
.admin_get_all_emails(query)
|
|
.await
|
|
.expect("failed to search emails");
|
|
assert!(
|
|
users
|
|
.iter()
|
|
.any(|u| u.email.as_ref().unwrap() == "pipis@noreply.example.org"),
|
|
"could not find new user"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn org() {
|
|
let api = common::login();
|
|
|
|
let user_opt = CreateUserOption {
|
|
created_at: None,
|
|
email: "org-owner@noreply.example.org".into(),
|
|
full_name: None,
|
|
login_name: None,
|
|
must_change_password: None,
|
|
password: Some("userpass".into()),
|
|
restricted: Some(false),
|
|
send_notify: Some(true),
|
|
source_id: None,
|
|
username: "OrgOwner".into(),
|
|
visibility: Some("public".into()),
|
|
};
|
|
let _ = api
|
|
.admin_create_user(user_opt)
|
|
.await
|
|
.expect("failed to create user");
|
|
|
|
let org_opt = CreateOrgOption {
|
|
description: None,
|
|
email: None,
|
|
full_name: None,
|
|
location: None,
|
|
repo_admin_change_team_access: None,
|
|
username: "test-org".into(),
|
|
visibility: Some(CreateOrgOptionVisibility::Public),
|
|
website: None,
|
|
};
|
|
let _ = api
|
|
.admin_create_org("OrgOwner", org_opt)
|
|
.await
|
|
.expect("failed to create org");
|
|
let query = AdminGetAllOrgsQuery::default();
|
|
assert!(
|
|
!api.admin_get_all_orgs(query).await.unwrap().is_empty(),
|
|
"org list empty"
|
|
);
|
|
let rename_opt = RenameUserOption {
|
|
new_username: "Bepis".into(),
|
|
};
|
|
api.admin_rename_user("Pipis", rename_opt)
|
|
.await
|
|
.expect("failed to rename user");
|
|
let query = AdminDeleteUserQuery { purge: Some(true) };
|
|
api.admin_delete_user("Bepis", query)
|
|
.await
|
|
.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"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn key() {
|
|
let api = common::login();
|
|
|
|
let user_opt = CreateUserOption {
|
|
created_at: None,
|
|
email: "key-holder@noreply.example.org".into(),
|
|
full_name: None,
|
|
login_name: None,
|
|
must_change_password: None,
|
|
password: Some("userpass".into()),
|
|
restricted: Some(false),
|
|
send_notify: Some(true),
|
|
source_id: None,
|
|
username: "KeyHolder".into(),
|
|
visibility: Some("public".into()),
|
|
};
|
|
let _ = api
|
|
.admin_create_user(user_opt)
|
|
.await
|
|
.expect("failed to create user");
|
|
|
|
let key_opt = CreateKeyOption {
|
|
key: "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIN68ehQAsbGEwlXPa2AxbAh1QxFQrtRel2jeC0hRlPc1 user@noreply.example.org".into(),
|
|
read_only: None,
|
|
title: "Example Key".into(),
|
|
};
|
|
let key = api
|
|
.admin_create_public_key("KeyHolder", key_opt)
|
|
.await
|
|
.expect("failed to create key");
|
|
api.admin_delete_user_public_key("KeyHolder", key.id.unwrap() as u64)
|
|
.await
|
|
.expect("failed to delete key");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn cron() {
|
|
let api = common::login();
|
|
|
|
let query = AdminCronListQuery::default();
|
|
let crons = api
|
|
.admin_cron_list(query)
|
|
.await
|
|
.expect("failed to get crons list");
|
|
api.admin_cron_run(crons.first().expect("no crons").name.as_ref().unwrap())
|
|
.await
|
|
.expect("failed to run cron");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn hook() {
|
|
let api = common::login();
|
|
let hook_opt = CreateHookOption {
|
|
active: None,
|
|
authorization_header: None,
|
|
branch_filter: None,
|
|
config: CreateHookOptionConfig {
|
|
content_type: "json".into(),
|
|
url: url::Url::parse("http://test.local/").unwrap(),
|
|
additional: Default::default(),
|
|
},
|
|
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
|
|
.expect("failed to create hook");
|
|
let edit_hook = EditHookOption {
|
|
active: Some(true),
|
|
authorization_header: None,
|
|
branch_filter: None,
|
|
config: None,
|
|
events: None,
|
|
};
|
|
api.admin_edit_hook(hook.id.unwrap() as u64, edit_hook)
|
|
.await
|
|
.expect("failed to edit hook");
|
|
api.admin_delete_hook(hook.id.unwrap() as u64)
|
|
.await
|
|
.expect("failed to delete hook");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn quota_group() {
|
|
let api = common::login();
|
|
|
|
let user_opts = CreateUserOption {
|
|
created_at: None,
|
|
email: "1997@example.com".into(),
|
|
full_name: None,
|
|
login_name: None,
|
|
must_change_password: None,
|
|
password: Some("dialtone".into()),
|
|
restricted: None,
|
|
send_notify: None,
|
|
source_id: None,
|
|
username: "salesman".into(),
|
|
visibility: None,
|
|
};
|
|
api.admin_create_user(user_opts)
|
|
.await
|
|
.expect("failed to create user");
|
|
|
|
let group = CreateQuotaGroupOptions {
|
|
name: Some("no doing anything".into()),
|
|
rules: Some(vec![CreateQuotaRuleOptions {
|
|
limit: Some(0),
|
|
name: Some("blah".into()),
|
|
subjects: Some(vec![CreateQuotaRuleOptionsSubjects::SizeAll]),
|
|
}]),
|
|
};
|
|
let quota_group = api
|
|
.admin_create_quota_group(group)
|
|
.await
|
|
.expect("failed to create quota group");
|
|
|
|
api.admin_add_user_to_quota_group("no doing anything", "salesman")
|
|
.await
|
|
.expect("failed to add user to quota group");
|
|
|
|
assert!(quota_group
|
|
.name
|
|
.as_ref()
|
|
.is_some_and(|name| name == "no doing anything"));
|
|
assert!(quota_group
|
|
.rules
|
|
.as_ref()
|
|
.is_some_and(|rules| rules.len() == 1));
|
|
|
|
let quota_groups = api
|
|
.admin_list_quota_groups()
|
|
.await
|
|
.expect("failed to list quota groups");
|
|
assert_eq!(quota_groups.len(), 1);
|
|
assert_eq!("a_groups[0], "a_group);
|
|
|
|
let quota_info = api
|
|
.admin_get_user_quota("salesman")
|
|
.await
|
|
.expect("failed to get user quota");
|
|
let usage = quota_info
|
|
.used
|
|
.expect("quota info missing usage info")
|
|
.size
|
|
.expect("quota info missing size info");
|
|
assert!(usage
|
|
.git
|
|
.is_some_and(|git| git.lfs.is_some_and(|lfs| lfs == 0)));
|
|
assert!(usage
|
|
.repos
|
|
.as_ref()
|
|
.is_some_and(|repos| repos.public.is_some_and(|lfs| lfs == 0)));
|
|
assert!(usage
|
|
.repos
|
|
.is_some_and(|repos| repos.private.is_some_and(|lfs| lfs == 0)));
|
|
assert!(usage
|
|
.assets
|
|
.is_some_and(|assets| assets.artifacts.is_some_and(|lfs| lfs == 0)));
|
|
|
|
api.admin_remove_rule_from_quota_group("no doing anything", "blah")
|
|
.await
|
|
.expect("failed to delete rule from quota group");
|
|
api.admin_remove_user_from_quota_group("no doing anything", "salesman")
|
|
.await
|
|
.expect("failed to remove user from quota group");
|
|
api.admin_delete_quota_group("no doing anything")
|
|
.await
|
|
.expect("failed to delete quota group");
|
|
}
|