Merge pull request 'test repository methods' (#24) from repo-tests into main

Reviewed-on: https://codeberg.org/Cyborus/forgejo-api/pulls/24

1 files changed, 76 insertions, 45 deletions

diff --git a/tests/ci_test.rs b/tests/ci_test.rs
index 08ee904..52e5efe 100644
--- a/tests/ci_test.rs
+++ b/tests/ci_test.rs
@@ -1,5 +1,5 @@
 use forgejo_api::Forgejo;
-use eyre::{eyre, ensure};
+use eyre::{eyre, ensure, WrapErr};
 
 #[tokio::test]
 async fn ci() -> eyre::Result<()> {
@@ -9,13 +9,20 @@ async fn ci() -> eyre::Result<()> {
 
     let mut results = Vec::new();
 
-    results.push(user(&api).await.map_err(|e| eyre!("user error: {e}")));
-    results.push(repo(&api).await.map_err(|e| eyre!("repo error: {e}")));
+    results.push(user(&api).await.wrap_err("user error"));
+    results.push(repo(&api).await.wrap_err("repo error"));
 
     let mut errors = 0;
-    for res in results.into_iter().filter_map(Result::err) {
+    for report in results.into_iter().filter_map(Result::err) {
         errors += 1;
-        println!("{res}");
+        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");
@@ -45,19 +52,19 @@ async fn user(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
 
 async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
     tokio::fs::create_dir("/test_repo").await?;
-    let local_repo = git2::Repository::init("/test_repo")?;
+    let git = || {
+        let mut cmd = std::process::Command::new("git");
+        cmd.current_dir("/test_repo");
+        cmd
+    };
+    let _ = git().args(["config", "--global", "init.defaultBranch", "main"]).status()?;
+    let _ = git().args(["init"]).status()?;
+    let _ = git().args(["config", "user.name", "TestingAdmin"]).status()?;
+    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()?;
 
-    let mut index = local_repo.index()?;
-    index.add_all(["."], git2::IndexAddOption::DEFAULT, None)?;
-    index.write()?;
-    let tree = local_repo.find_tree(index.write_tree().unwrap())?;
-    let author = git2::Signature::now("TestingAdmin", "admin@noreply.example.org").unwrap();
-    let commit_oid = local_repo.commit(None, &author, &author, "bibblybeebly", &tree, &[])?;
-    let branch = local_repo.branch("main", &local_repo.find_commit(commit_oid).unwrap(), true)?;
-    let branch_ref = branch.into_reference();
-    let branch_ref_name = branch_ref.name().ok_or_else(|| eyre!("branch name not found"))?;
-    local_repo.set_head(branch_ref_name)?;
 
     let repo_opt = forgejo_api::CreateRepoOption {
         auto_init: false,
@@ -73,36 +80,22 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
         trust_model: forgejo_api::TrustModel::Default,
     };
     let remote_repo = api.create_repo(repo_opt).await?;
+    ensure!(remote_repo.has_pull_requests, "repo does not accept pull requests");
     ensure!(remote_repo.owner.login == "TestingAdmin", "repo owner is not \"TestingAdmin\"");
     ensure!(remote_repo.name == "test", "repo owner is not \"test\"");
+    tokio::time::sleep(std::time::Duration::from_secs(3)).await;
 
-    let mut callbacks = git2::RemoteCallbacks::new();
-    callbacks.credentials(|_url, _username_from_url, _allowed_types| {
-        git2::Cred::userpass_plaintext("TestingAdmin", "password")
-    });
-    let mut push_options = git2::PushOptions::new();
-    push_options.remote_callbacks(callbacks);
-    let mut origin = local_repo.remote("origin", remote_repo.clone_url.as_str())?;
-    origin.push(&[branch_ref_name], Some(&mut push_options))?;
+    let mut remote_url = remote_repo.clone_url.clone();
+    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()?;
 
+    let _ = git().args(["switch", "-c", "test"]).status()?;
     tokio::fs::write("/test_repo/example.rs", "fn add_one(x: u32) -> u32 { x + 1 }").await?;
-    let mut index = local_repo.index()?;
-    index.add_all(["."], git2::IndexAddOption::DEFAULT, None)?;
-    index.write()?;
-    let tree = local_repo.find_tree(index.write_tree().unwrap())?;
-    let commit_oid = local_repo.commit(None, &author, &author, "egg", &tree, &[])?;
-    let branch = local_repo.branch("test", &local_repo.find_commit(commit_oid).unwrap(), true)?;
-    let branch_ref = branch.into_reference();
-    let branch_ref_name = branch_ref.name().ok_or_else(|| eyre!("branch name not found"))?;
-    local_repo.set_head(branch_ref_name)?;
-
-    let mut callbacks = git2::RemoteCallbacks::new();
-    callbacks.credentials(|_url, _username_from_url, _allowed_types| {
-        git2::Cred::userpass_plaintext("TestingAdmin", "password")
-    });
-    let mut push_options = git2::PushOptions::new();
-    push_options.remote_callbacks(callbacks);
-    origin.push(&[branch_ref_name], Some(&mut push_options)).map_err(|e| eyre!("failed to push branch, {e}"))?;
+    let _ = git().args(["add", "."]).status()?;
+    let _ = git().args(["commit", "-m", "egg"]).status()?;
+    let _ = git().args(["push", "-u", "origin", "test"]).status()?;
 
     let pr_opt = forgejo_api::CreatePullRequestOption {
         assignee: None,
@@ -115,8 +108,9 @@ async fn repo(api: &forgejo_api::Forgejo) -> eyre::Result<()> {
         milestone: None,
         title: "test pr".into(),
     };
-    let pr = api.create_pr("TestingAdmin", "test", pr_opt).await.map_err(|e| eyre!("couldn't create pr, {e}"))?;
-    let is_merged = api.is_merged("TestingAdmin", "test", pr.number).await.map_err(|e| eyre!("couldn't find unmerged pr {}, {}", pr.number, e))?;
+    let pr = api.create_pr("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).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,
@@ -128,9 +122,46 @@ 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).await.map_err(|e| eyre!("couldn't merge pr {}, {}", pr.number, e))?;
-    let is_merged = api.is_merged("TestingAdmin", "test", pr.number).await.map_err(|e| eyre!("couldn't find merged pr {}, {}", pr.number, e))?;
+    api.merge_pr("TestingAdmin", "test", pr.number, merge_opt).await.wrap_err_with(|| eyre!("couldn't merge pr {}", pr.number))?;
+    let is_merged = api.is_merged("TestingAdmin", "test", pr.number).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()).await.wrap_err("releases list not found")?.is_empty(), "there should be no releases yet");
+
+    let tag_opt = forgejo_api::CreateTagOption {
+        message: Some("This is a tag!".into()),
+        tag_name: "v1.0".into(),
+        target: None,
+    };
+    api.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,
+        tag_name: "v1.0".into(),
+        target_commitish: None,
+    };
+    let release = api.create_release("TestingAdmin", "test", release_opt).await.wrap_err("failed to create release")?;
+    let edit_release = forgejo_api::EditReleaseOption {
+        draft: Some(false),
+        ..Default::default()
+    };
+    api.edit_release("TestingAdmin", "test", release.id, edit_release).await.wrap_err("failed to edit release")?;
+
+    let release_by_tag = api.get_release_by_tag("TestingAdmin", "test", "v1.0").await.wrap_err("failed to find release")?;
+    let release_latest = api.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("TestingAdmin", "test", release.id, "test.txt", b"This is a file!".to_vec()).await.wrap_err("failed to create release attachment")?;
+    api.delete_release_attachment("TestingAdmin", "test", release.id, attachment.id).await.wrap_err("failed to deleted attachment")?;
+
+    api.delete_release("TestingAdmin", "test", release.id).await.wrap_err("failed to delete release")?;
+
+    api.delete_tag("TestingAdmin", "test", "v1.0").await.wrap_err("failed to delete release")?;
 
     Ok(())
 }