Adding upstream version 0.4.1.

Signed-off-by: Daniel Baumann <daniel@debian.org>

tests/admin.rs

@@ -0,0 +1,194 @@
+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()
+            .find(|u| u.login.as_ref().unwrap() == "Pipis")
+            .is_some(),
+        "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()
+            .find(|u| u.email.as_ref().unwrap() == "pipis@noreply.example.org")
+            .is_some(),
+        "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.get(0).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");
+}

tests/common/mod.rs

@@ -0,0 +1,17 @@
+use forgejo_api::Forgejo;
+
+pub fn login() -> 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()
+}
+
+pub fn login_pass(username: &str, password: &str) -> Forgejo {
+    let url = url::Url::parse(&std::env::var("FORGEJO_API_CI_INSTANCE_URL").unwrap()).unwrap();
+    let auth = forgejo_api::Auth::Password {
+        username,
+        password,
+        mfa: None,
+    };
+    Forgejo::new(auth, url).unwrap()
+}

tests/organization.rs

@@ -0,0 +1,58 @@
+use forgejo_api::structs::*;
+
+mod common;
+
+#[tokio::test]
+async fn org_vars() {
+    let api = common::login();
+    let org_opt = CreateOrgOption {
+        description: Some("Testing organization variables".into()),
+        email: None,
+        full_name: Some("Org Variables".into()),
+        location: Some("The Lab".into()),
+        repo_admin_change_team_access: None,
+        username: "org-vars".into(),
+        visibility: None,
+        website: None,
+    };
+    api.org_create(org_opt).await.expect("failed to create org");
+
+    let query = GetOrgVariablesListQuery::default();
+    let var_list = api
+        .get_org_variables_list("org-vars", query)
+        .await
+        .expect("failed to list org vars");
+    assert!(var_list.is_empty());
+
+    let opt = CreateVariableOption {
+        value: "false".into(),
+    };
+    api.create_org_variable("org-vars", "want_pizza", opt)
+        .await
+        .expect("failed to create org var");
+
+    let new_var = api
+        .get_org_variable("org-vars", "want_pizza")
+        .await
+        .expect("failed to get org var");
+    assert_eq!(new_var.data.as_deref(), Some("false"));
+
+    // no no no we definitely do want pizza
+    let opt = UpdateVariableOption {
+        name: Some("really_want_pizza".into()),
+        value: "true".into(),
+    };
+    api.update_org_variable("org-vars", "want_pizza", opt)
+        .await
+        .expect("failed to update org variable");
+
+    let new_var = api
+        .get_org_variable("org-vars", "really_want_pizza")
+        .await
+        .expect("failed to get org var");
+    assert_eq!(new_var.data.as_deref(), Some("true"));
+
+    api.delete_org_variable("org-vars", "really_want_pizza")
+        .await
+        .expect("failed to delete org var");
+}

tests/repo.rs

@@ -0,0 +1,495 @@
+use forgejo_api::structs::*;
+
+mod common;
+
+struct Git {
+    dir: &'static std::path::Path,
+}
+
+impl Git {
+    fn new<T: AsRef<std::path::Path> + ?Sized>(path: &'static T) -> Self {
+        let dir = path.as_ref();
+        std::fs::create_dir_all(dir).unwrap();
+        Self { dir }
+    }
+
+    fn run(&self, args: &[impl AsRef<std::ffi::OsStr>]) {
+        let mut cmd = std::process::Command::new("git");
+        cmd.current_dir(self.dir);
+        let _ = cmd.args(args).status().unwrap();
+    }
+}
+
+async fn setup_local_repo(git: &Git) {
+    git.run(&["config", "--global", "init.defaultBranch", "main"]);
+    git.run(&["init"]);
+    git.run(&["config", "user.name", "TestingAdmin"]);
+    git.run(&["config", "user.email", "admin@noreply.example.org"]);
+    tokio::fs::write(&git.dir.join("README.md"), "# Test\nThis is a test repo")
+        .await
+        .unwrap();
+    git.run(&["add", "."]);
+    git.run(&["commit", "-m", "initial commit"]);
+}
+
+async fn basic_repo(api: &forgejo_api::Forgejo, git: &Git, name: &str) -> Repository {
+    setup_local_repo(git).await;
+    let repo_opt = CreateRepoOption {
+        auto_init: Some(false),
+        default_branch: Some("main".into()),
+        description: Some("Test Repo".into()),
+        gitignores: Some("".into()),
+        issue_labels: Some("".into()),
+        license: Some("".into()),
+        name: name.into(),
+        object_format_name: None,
+        private: Some(false),
+        readme: None,
+        template: Some(false),
+        trust_model: Some(CreateRepoOptionTrustModel::Default),
+    };
+    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"
+    );
+    assert!(
+        remote_repo.owner.as_ref().unwrap().login.as_ref().unwrap() == "TestingAdmin",
+        "repo owner is not \"TestingAdmin\""
+    );
+    assert!(
+        remote_repo.name.as_ref().unwrap() == name,
+        "repo name is not \"{name}\""
+    );
+
+    let mut remote_url = remote_repo.clone_url.clone().unwrap();
+    remote_url.set_username("TestingAdmin").unwrap();
+    remote_url.set_password(Some("password")).unwrap();
+    git.run(&["remote", "add", "origin", remote_url.as_str()]);
+    git.run(&["push", "-u", "origin", "main"]);
+
+    remote_repo
+}
+
+async fn basic_org_repo(
+    api: &forgejo_api::Forgejo,
+    git: &Git,
+    org: &str,
+    name: &str,
+) -> Repository {
+    setup_local_repo(git).await;
+
+    let repo_opt = CreateRepoOption {
+        auto_init: Some(false),
+        default_branch: Some("main".into()),
+        description: Some("Test Repo".into()),
+        gitignores: Some("".into()),
+        issue_labels: Some("".into()),
+        license: Some("".into()),
+        name: name.into(),
+        object_format_name: None,
+        private: Some(false),
+        readme: None,
+        template: Some(false),
+        trust_model: Some(CreateRepoOptionTrustModel::Default),
+    };
+    let remote_repo = api.create_org_repo(org, repo_opt).await.unwrap();
+    assert!(
+        remote_repo.has_pull_requests.unwrap(),
+        "repo does not accept pull requests"
+    );
+    assert!(
+        remote_repo.owner.as_ref().unwrap().login.as_ref().unwrap() == org,
+        "repo owner is not \"TestingAdmin\""
+    );
+    assert!(
+        remote_repo.name.as_ref().unwrap() == name,
+        "repo name is not \"{name}\""
+    );
+
+    let mut remote_url = remote_repo.clone_url.clone().unwrap();
+    remote_url.set_username("TestingAdmin").unwrap();
+    remote_url.set_password(Some("password")).unwrap();
+    git.run(&["remote", "add", "origin", remote_url.as_str()]);
+    git.run(&["push", "-u", "origin", "main"]);
+
+    remote_repo
+}
+
+#[tokio::test]
+async fn pull_request() {
+    let api = common::login();
+
+    let git = Git::new("./test_repos/pr");
+    let _ = basic_repo(&api, &git, "pr-test").await;
+    git.run(&["switch", "-c", "test"]);
+
+    tokio::fs::write(
+        "./test_repos/pr/example.rs",
+        "fn add_one(x: u32) -> u32 { x + 1 }",
+    )
+    .await
+    .unwrap();
+    git.run(&["add", "."]);
+    git.run(&["commit", "-m", "egg"]);
+    git.run(&["push", "-u", "origin", "test"]);
+
+    let pr_opt = CreatePullRequestOption {
+        assignee: None,
+        assignees: Some(vec!["TestingAdmin".into()]),
+        base: Some("main".into()),
+        body: Some("This is a test PR".into()),
+        due_date: None,
+        head: Some("test".into()),
+        labels: None,
+        milestone: None,
+        title: Some("test pr".into()),
+    };
+
+    // Wait for... something to happen, or else creating a PR will return 404
+    tokio::time::sleep(std::time::Duration::from_secs(3)).await;
+    let pr = api
+        .repo_create_pull_request("TestingAdmin", "pr-test", pr_opt)
+        .await
+        .expect("couldn't create pr");
+
+    let is_merged = api
+        .repo_pull_request_is_merged("TestingAdmin", "pr-test", pr.number.unwrap() as u64)
+        .await
+        .is_ok();
+    assert!(!is_merged, "pr should not yet be merged");
+
+    let pr_files_query = RepoGetPullRequestFilesQuery::default();
+    let (_, _) = api
+        .repo_get_pull_request_files(
+            "TestingAdmin",
+            "pr-test",
+            pr.number.unwrap() as u64,
+            pr_files_query,
+        )
+        .await
+        .unwrap();
+
+    let merge_opt = MergePullRequestOption {
+        r#do: MergePullRequestOptionDo::Merge,
+        merge_commit_id: None,
+        merge_message_field: None,
+        merge_title_field: None,
+        delete_branch_after_merge: Some(true),
+        force_merge: None,
+        head_commit_id: None,
+        merge_when_checks_succeed: None,
+    };
+
+    api.repo_merge_pull_request(
+        "TestingAdmin",
+        "pr-test",
+        pr.number.unwrap() as u64,
+        merge_opt,
+    )
+    .await
+    .expect("couldn't merge pr");
+    let is_merged = api
+        .repo_pull_request_is_merged("TestingAdmin", "pr-test", pr.number.unwrap() as u64)
+        .await
+        .is_ok();
+    assert!(is_merged, "pr should be merged");
+}
+
+#[tokio::test]
+async fn release() {
+    let api = common::login();
+
+    let git = Git::new("./test_repos/release");
+    let _ = basic_repo(&api, &git, "release-test").await;
+
+    // Wait for the repo to be finished being populated, or else creating a
+    // release will return "422 repo is empty"
+    tokio::time::sleep(std::time::Duration::from_secs(3)).await;
+
+    let query = RepoListReleasesQuery::default();
+    assert!(
+        api.repo_list_releases("TestingAdmin", "release-test", query)
+            .await
+            .unwrap()
+            .is_empty(),
+        "there should be no releases yet"
+    );
+
+    let tag_opt = CreateTagOption {
+        message: Some("This is a tag!".into()),
+        tag_name: "v1.0".into(),
+        target: None,
+    };
+    api.repo_create_tag("TestingAdmin", "release-test", tag_opt)
+        .await
+        .expect("failed to create tag");
+
+    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,
+        hide_archive_links: None,
+    };
+    let release = api
+        .repo_create_release("TestingAdmin", "release-test", release_opt)
+        .await
+        .expect("failed to create release");
+    let edit_release = EditReleaseOption {
+        body: None,
+        draft: Some(false),
+        name: None,
+        prerelease: None,
+        tag_name: None,
+        target_commitish: None,
+        hide_archive_links: None,
+    };
+    api.repo_edit_release(
+        "TestingAdmin",
+        "release-test",
+        release.id.unwrap() as u64,
+        edit_release,
+    )
+    .await
+    .expect("failed to edit release");
+
+    let release_by_tag = api
+        .repo_get_release_by_tag("TestingAdmin", "release-test", "v1.0")
+        .await
+        .expect("failed to find release");
+    let release_latest = api
+        .repo_get_latest_release("TestingAdmin", "release-test")
+        .await
+        .expect("failed to find latest release");
+    assert!(release_by_tag == release_latest, "releases not equal");
+
+    let attachment = api
+        .repo_create_release_attachment(
+            "TestingAdmin",
+            "release-test",
+            release.id.unwrap() as u64,
+            b"This is a file!".to_vec(),
+            RepoCreateReleaseAttachmentQuery {
+                name: Some("test.txt".into()),
+            },
+        )
+        .await
+        .expect("failed to create release attachment");
+    assert!(
+        &*api
+            .download_release_attachment(
+                "TestingAdmin",
+                "release-test",
+                release.id.unwrap() as u64,
+                attachment.id.unwrap() as u64
+            )
+            .await
+            .unwrap()
+            == b"This is a file!",
+        "couldn't download attachment"
+    );
+    let _zip_archive = api
+        .repo_get_archive("TestingAdmin", "release-test", "v1.0.zip")
+        .await
+        .unwrap();
+    let _tar_archive = api
+        .repo_get_archive("TestingAdmin", "release-test", "v1.0.tar.gz")
+        .await
+        .unwrap();
+    // check these contents when their return value is fixed
+
+    api.repo_delete_release_attachment(
+        "TestingAdmin",
+        "release-test",
+        release.id.unwrap() as u64,
+        attachment.id.unwrap() as u64,
+    )
+    .await
+    .expect("failed to deleted attachment");
+
+    api.repo_delete_release("TestingAdmin", "release-test", release.id.unwrap() as u64)
+        .await
+        .expect("failed to delete release");
+
+    api.repo_delete_tag("TestingAdmin", "release-test", "v1.0")
+        .await
+        .expect("failed to delete release");
+}
+
+#[tokio::test]
+async fn delete_repo() {
+    let api = common::login();
+    let git = Git::new("./test_repos/delete");
+    let _ = basic_repo(&api, &git, "delete-test").await;
+
+    api.repo_delete("TestingAdmin", "delete-test")
+        .await
+        .expect("failed to delete repo");
+}
+
+#[tokio::test]
+async fn team_pr_review_request() {
+    let api = common::login();
+
+    let org_opt = CreateOrgOption {
+        description: Some("Testing team review requests".into()),
+        email: None,
+        full_name: None,
+        location: None,
+        repo_admin_change_team_access: None,
+        username: "team-review-org".into(),
+        visibility: None,
+        website: None,
+    };
+    api.org_create(org_opt).await.unwrap();
+
+    let git = Git::new("./test_repos/team-pr-review");
+    let _ = basic_org_repo(&api, &git, "team-review-org", "team-pr-review").await;
+
+    git.run(&["switch", "-c", "test"]);
+    tokio::fs::write(
+        "./test_repos/team-pr-review/example.rs",
+        "fn add_one(x: u32) -> u32 { x + 1 }",
+    )
+    .await
+    .unwrap();
+    git.run(&["add", "."]);
+    git.run(&["commit", "-m", "egg"]);
+    git.run(&["push", "-u", "origin", "test"]);
+
+    let pr_opt = CreatePullRequestOption {
+        assignee: None,
+        assignees: Some(vec!["TestingAdmin".into()]),
+        base: Some("main".into()),
+        body: Some("This is a test PR".into()),
+        due_date: None,
+        head: Some("test".into()),
+        labels: None,
+        milestone: None,
+        title: Some("test pr".into()),
+    };
+
+    // Wait for... something to happen, or else creating a PR will return 404
+    tokio::time::sleep(std::time::Duration::from_secs(3)).await;
+    api.repo_create_pull_request("team-review-org", "team-pr-review", pr_opt)
+        .await
+        .expect("couldn't create pr");
+
+    let review_opt = PullReviewRequestOptions {
+        reviewers: None,
+        team_reviewers: Some(vec!["Owners".into()]),
+    };
+    api.repo_create_pull_review_requests("team-review-org", "team-pr-review", 1, review_opt)
+        .await
+        .expect("couldn't request review");
+
+    let pr = api
+        .repo_get_pull_request("team-review-org", "team-pr-review", 1)
+        .await
+        .expect("couldn't get pr");
+    assert_eq!(pr.requested_reviewers, Some(Vec::new()));
+}
+
+#[tokio::test]
+async fn tag_protection() {
+    let api = common::login();
+    let git = Git::new("./test_repos/tag-protect");
+    let _ = basic_repo(&api, &git, "tag-protect").await;
+
+    let tag_protections = api
+        .repo_list_tag_protection("TestingAdmin", "tag-protect")
+        .await
+        .expect("failed to list tag protections");
+    assert!(tag_protections.is_empty());
+
+    let protection_opt = CreateTagProtectionOption {
+        name_pattern: Some("v*".into()),
+        whitelist_teams: None,
+        whitelist_usernames: Some(vec!["TestingAdmin".into()]),
+    };
+    let new_protection = api
+        .repo_create_tag_protection("TestingAdmin", "tag-protect", protection_opt)
+        .await
+        .expect("failed to create tag protection");
+    let pattern = new_protection
+        .name_pattern
+        .as_deref()
+        .expect("protection does not have pattern");
+    assert_eq!(pattern, "v*");
+    let id = new_protection.id.expect("protection does not have id") as u32;
+
+    let protection_get = api
+        .repo_get_tag_protection("TestingAdmin", "tag-protect", id)
+        .await
+        .expect("failed to get tag protection");
+    assert_eq!(new_protection, protection_get);
+
+    let edit_opt = EditTagProtectionOption {
+        name_pattern: Some("v*.*.*".into()),
+        whitelist_teams: None,
+        whitelist_usernames: Some(vec![]),
+    };
+    let edited = api
+        .repo_edit_tag_protection("TestingAdmin", "tag-protect", id, edit_opt)
+        .await
+        .expect("failed to edit tag protection");
+    let pattern = edited
+        .name_pattern
+        .as_deref()
+        .expect("protection does not have pattern");
+    assert_eq!(pattern, "v*.*.*");
+
+    api.repo_delete_tag_protection("TestingAdmin", "tag-protect", id)
+        .await
+        .expect("failed to delete tag protection");
+}
+
+#[tokio::test]
+async fn repo_vars() {
+    let api = common::login();
+    let git = Git::new("./test_repos/repo-vars");
+    let _ = basic_repo(&api, &git, "repo-vars").await;
+
+    let query = GetRepoVariablesListQuery::default();
+    let var_list = api
+        .get_repo_variables_list("TestingAdmin", "repo-vars", query)
+        .await
+        .expect("failed to list repo vars");
+    assert!(var_list.is_empty());
+
+    let opt = CreateVariableOption {
+        value: "false".into(),
+    };
+    api.create_repo_variable("TestingAdmin", "repo-vars", "very_cool", opt)
+        .await
+        .expect("failed to create repo var");
+
+    let new_var = api
+        .get_repo_variable("TestingAdmin", "repo-vars", "very_cool")
+        .await
+        .expect("failed to get repo var");
+    assert_eq!(new_var.data.as_deref(), Some("false"));
+
+    // wait, that's not right. you ARE very cool!
+    // gotta fix that
+    let opt = UpdateVariableOption {
+        name: Some("extremely_cool".into()),
+        value: "true".into(),
+    };
+    api.update_repo_variable("TestingAdmin", "repo-vars", "very_cool", opt)
+        .await
+        .expect("failed to update repo variable");
+
+    let new_var = api
+        .get_repo_variable("TestingAdmin", "repo-vars", "extremely_cool")
+        .await
+        .expect("failed to get repo var");
+    assert_eq!(new_var.data.as_deref(), Some("true"));
+
+    api.delete_repo_variable("TestingAdmin", "repo-vars", "extremely_cool")
+        .await
+        .expect("failed to delete repo var");
+}

tests/user.rs

@@ -0,0 +1,237 @@
+use forgejo_api::structs::*;
+
+mod common;
+
+#[tokio::test]
+async fn myself() {
+    let api = common::login();
+
+    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.user_get("TestingAdmin").await.unwrap();
+    assert_eq!(
+        myself, myself_indirect,
+        "result of `myself` does not match result of `get_user`"
+    );
+}
+
+#[tokio::test]
+async fn follow() {
+    let api = common::login();
+
+    let query = UserListFollowingQuery::default();
+    let following = api
+        .user_list_following("TestingAdmin", query)
+        .await
+        .unwrap();
+    assert!(following.is_empty(), "following list not empty");
+
+    let query = UserListFollowersQuery::default();
+    let followers = api
+        .user_list_followers("TestingAdmin", query)
+        .await
+        .unwrap();
+    assert!(followers.is_empty(), "follower list not empty");
+
+    let option = CreateUserOption {
+        created_at: None,
+        email: "follower@no-reply.example.org".into(),
+        full_name: None,
+        login_name: None,
+        must_change_password: Some(false),
+        password: Some("password".into()),
+        restricted: None,
+        send_notify: None,
+        source_id: None,
+        username: "Follower".into(),
+        visibility: None,
+    };
+    let _ = api.admin_create_user(option).await.unwrap();
+    let new_user = common::login_pass("Follower", "password");
+
+    new_user
+        .user_current_put_follow("TestingAdmin")
+        .await
+        .unwrap();
+    api.user_current_put_follow("Follower").await.unwrap();
+
+    let query = UserListFollowingQuery::default();
+    let following = api
+        .user_list_following("TestingAdmin", query)
+        .await
+        .unwrap();
+    assert!(!following.is_empty(), "following list empty");
+
+    let query = UserListFollowersQuery::default();
+    let followers = api
+        .user_list_followers("TestingAdmin", query)
+        .await
+        .unwrap();
+    assert!(!followers.is_empty(), "follower list empty");
+}
+
+#[tokio::test]
+async fn password_login() {
+    let api = common::login();
+    let password_api = common::login_pass("TestingAdmin", "password");
+
+    assert!(
+        api.user_get_current().await.unwrap() == password_api.user_get_current().await.unwrap(),
+        "users not equal comparing token-auth and pass-auth"
+    );
+}
+
+#[tokio::test]
+async fn oauth2_login() {
+    let api = common::login();
+    let opt = forgejo_api::structs::CreateOAuth2ApplicationOptions {
+        confidential_client: Some(true),
+        name: Some("Test Application".into()),
+        redirect_uris: Some(vec!["http://127.0.0.1:48879/".into()]),
+    };
+    let app = api.user_create_oauth2_application(opt).await.unwrap();
+    let client_id = app.client_id.unwrap();
+    let client_secret = app.client_secret.unwrap();
+
+    let base_url = &std::env::var("FORGEJO_API_CI_INSTANCE_URL").unwrap();
+
+    let client = reqwest::Client::builder()
+        .cookie_store(true)
+        .redirect(reqwest::redirect::Policy::none())
+        .build()
+        .unwrap();
+
+    // Log in via the web interface
+    let _ = client
+        .post(&format!("{base_url}user/login"))
+        .form(&[("user_name", "TestingAdmin"), ("password", "password")])
+        .send()
+        .await
+        .unwrap()
+        .error_for_status()
+        .unwrap();
+
+    // Load the authorization page
+    let response = client
+        .get(&format!(
+            "{base_url}login/oauth/authorize\
+             ?client_id={client_id}\
+             &redirect_uri=http%3A%2F%2F127.0.0.1%3A48879%2F\
+             &response_type=code\
+             &state=theyve"
+        ))
+        .send()
+        .await
+        .unwrap()
+        .error_for_status()
+        .unwrap();
+    let csrf = response.cookies().find(|x| x.name() == "_csrf").unwrap();
+
+    // Authorize the new application via the web interface
+    let response = client
+        .post(&format!("{base_url}login/oauth/grant"))
+        .form(&[
+            ("_csrf", csrf.value()),
+            ("client_id", &client_id),
+            ("state", "theyve"),
+            ("scope", ""),
+            ("nonce", ""),
+            ("redirect_uri", "http://127.0.0.1:48879/"),
+        ])
+        .send()
+        .await
+        .unwrap()
+        .error_for_status()
+        .unwrap();
+
+    // Extract the code from the redirect url
+    let location = response.headers().get(reqwest::header::LOCATION).unwrap();
+    let location = url::Url::parse(dbg!(location.to_str().unwrap())).unwrap();
+    let mut code = None;
+    for (key, value) in location.query_pairs() {
+        if key == "code" {
+            code = Some(value.into_owned());
+        } else if key == "error_description" {
+            panic!("{value}");
+        }
+    }
+    let code = code.unwrap();
+
+    // Redeem the code and check it works
+    let url = url::Url::parse(&base_url).unwrap();
+    let api = forgejo_api::Forgejo::new(forgejo_api::Auth::None, url.clone()).unwrap();
+
+    let request = forgejo_api::structs::OAuthTokenRequest::Confidential {
+        client_id: &client_id,
+        client_secret: &client_secret,
+        code: &code,
+        redirect_uri: url::Url::parse("http://127.0.0.1:48879/").unwrap(),
+    };
+    let token = api.oauth_get_access_token(request).await.unwrap();
+    let token_api =
+        forgejo_api::Forgejo::new(forgejo_api::Auth::OAuth2(&token.access_token), url.clone())
+            .unwrap();
+    let myself = token_api.user_get_current().await.unwrap();
+    assert_eq!(myself.login.as_deref(), Some("TestingAdmin"));
+
+    let request = forgejo_api::structs::OAuthTokenRequest::Refresh {
+        refresh_token: &token.refresh_token,
+        client_id: &client_id,
+        client_secret: &client_secret,
+    };
+    let token = token_api.oauth_get_access_token(request).await.unwrap();
+    let token_api =
+        forgejo_api::Forgejo::new(forgejo_api::Auth::OAuth2(&token.access_token), url).unwrap();
+    let myself = token_api.user_get_current().await.unwrap();
+    assert_eq!(myself.login.as_deref(), Some("TestingAdmin"));
+}
+
+#[tokio::test]
+async fn user_vars() {
+    let api = common::login();
+
+    let query = GetUserVariablesListQuery::default();
+    let var_list = api
+        .get_user_variables_list(query)
+        .await
+        .expect("failed to list user vars");
+    assert!(var_list.is_empty());
+
+    let opt = CreateVariableOption {
+        value: "false".into(),
+    };
+    api.create_user_variable("likes_dogs", opt)
+        .await
+        .expect("failed to create user var");
+
+    let new_var = api
+        .get_user_variable("likes_dogs")
+        .await
+        .expect("failed to get user var");
+    assert_eq!(new_var.data.as_deref(), Some("false"));
+
+    // what??? totally wrong. I love dogs!
+    let opt = UpdateVariableOption {
+        name: Some("loves_dogs".into()),
+        value: "true".into(),
+    };
+    api.update_user_variable("likes_dogs", opt)
+        .await
+        .expect("failed to update user variable");
+
+    let new_var = api
+        .get_user_variable("loves_dogs")
+        .await
+        .expect("failed to get user var");
+    assert_eq!(new_var.data.as_deref(), Some("true"));
+
+    api.delete_user_variable("loves_dogs")
+        .await
+        .expect("failed to delete user var");
+}