Use pre Rust 1.81 compatible file-exists test

The function `std::fs::exists(...)` was stabilized in Rust 1.81, which
means it can't be used in the Debian Bookworm build. This patch swaps to
a compatible implementation leaning on the std::path::Path struct.

I'm both "upstreaming" a Debian-specific patch I had to make for the
package, and fixing the additional usage now in `main.rs`. There doesn't
seem to be any compelling reason to avoid using this function, so I
figure I should merge it into the base release.

README.md

@@ -51,14 +51,3 @@ One of these, defaults to `help`:
 | upload-release | Uploads one-or-more files to an existing release, identified by it's tag name. |
 | help | prints the help text (the usage summary above). |
 
-## Unit Testing
-
-The unit test~~s~~ require a Gitea server to execute against. This information is supplied by environment variables rather than on the command line, but it is otherwise exactly the same usage.
-
-| Variable | Description |
-|-|-|
-| TEST_GITEA_SERVER | Server URL, match `-u`, `--url` |
-| TEST_GITEA_REPO | Owner + repo name, match `-u` `--repo` |
-| TEST_GITEA_KEY | API key, match `RELEASE_KEY_GITEA`. The use of a new variable for the API token is to help avoid accidentally touching a production environment during test execution. |
-| TEST_GITEA_RELEASE_TAG | Git tag used to identify the Release. Same as `upload-release`'s positional argument `<TAG_NAME>`. |
-

src/api/release.rs

@@ -1,6 +1,6 @@
 
 use crate::{
-    ApiError, Result,
+    Result,
     structs::{
         release::{CreateReleaseOption, Release},
     },

src/api/release_attachment.rs

@@ -1,4 +1,4 @@
-use std::fs;
+use std::{fs, path};
 
 use crate::structs::Attachment;
 
@@ -16,7 +16,8 @@ pub async fn create_release_attachment(
 ) -> crate::Result<Attachment> {
     let request_url = format!("{gitea_url}/api/v1/repos/{repo}/releases/{release_id}/assets");
 
-    match fs::exists(&file) {
+    let path = path::Path::new(&file);
+    match path.try_exists() {
         Ok(true) => (),
         Ok(false) => return Err(crate::Error::NoSuchFile),
         Err(e) => {
@@ -53,140 +54,3 @@ pub async fn create_release_attachment(
 }
 pub fn edit_release_attachment() {}
 pub fn delete_release_attachment() {}
-
-#[cfg(test)]
-mod tests {
-    use reqwest::header::{self, ACCEPT};
-
-    use crate::structs::release::Release;
-
-
-    #[tokio::test]
-    async fn attach_file_exists() {
-        let conf = TestConfig::new();
-        let release_candidates =
-            crate::api::release::list_releases(
-                &conf.client,
-                &conf.server,
-                &conf.repo
-            )
-            .await
-            .expect("Failed to get releases. Pre-conditions unmet, aborting test!");
-
-        let release = match_release_by_tag(&conf.release_tag, release_candidates)
-            .expect("Failed to select matching release. Pre-conditions unmet, aborting test!");
-        
-        let api_result = super::create_release_attachment(
-            &conf.client,
-            &conf.server,
-            &conf.repo,
-            release.id,
-            vec![String::from("Cargo.toml")],
-        )
-        .await;
-    }
-
-    #[tokio::test]
-    async fn attach_file_missing() {
-        let conf = TestConfig::new();
-        let release_candidates =
-            crate::api::release::list_releases(
-                &conf.client,
-                &conf.server,
-                &conf.repo
-            )
-            .await
-            .expect("Failed to get releases. Pre-conditions unmet, aborting test!");
-
-        let release = match_release_by_tag(&conf.release_tag, release_candidates)
-            .expect("Failed to select matching release. Pre-conditions unmet, aborting test!");
-        
-        let api_result = super::create_release_attachment(
-            &conf.client,
-            &conf.server,
-            &conf.repo,
-            release.id,
-            vec![String::from("./this-file-doesnt-exist")],
-        )
-        .await;
-        let api_err = api_result.expect_err("Received Ok(()) after uploading non-existent file. That's nonsense, the API Function is wrong.");
-        match api_err {
-            crate::Error::Placeholder=>panic!("Received dummy response from the API function. Finish implementing it, stupid"),
-            crate::Error::WrappedReqwestErr(error)=>panic!("Received a reqwest::Error from the API function: {error}"),
-            crate::Error::MissingAuthToken=>unreachable!("Missing auth token... in a unit test that already panics without the auth token..."),
-            crate::Error::NoSuchFile=>(),
-            crate::Error::ApiErrorMessage(api_error)=>panic!("Received an error message from the API: {api_error:?}"),
-            crate::Error::NoSuchRelease => todo!(),
-        }
-    }
-
-    struct TestConfig {
-        server: String,
-        repo: String,
-        release_tag: String,
-        client: reqwest::Client,
-    }
-
-    impl TestConfig {
-        fn new() -> Self {
-            let server = std::env::var("TEST_GITEA_SERVER")
-                .expect("Must set server address in env var \"TEST_GITEA_SERVER\"");
-            let repo = std::env::var("TEST_GITEA_REPO")
-                .expect("Must set <user>/<repo> name in env var \"TEST_GITEA_REPO\"");
-            let token = format!(
-                "token {}",
-                std::env::var("TEST_GITEA_KEY")
-                    .expect("Must set the API token in env var \"TEST_GITEA_KEY\"")
-            );
-            let release_tag = std::env::var("TEST_GITEA_RELEASE_TAG")
-                .expect("Must set the target release tag in env var \"TEST_GITEA_RELEASE_TAG\"");
-
-            let mut headers = reqwest::header::HeaderMap::new();
-            headers.append(ACCEPT, header::HeaderValue::from_static("application/json"));
-            headers.append("Authorization", token.parse().unwrap());
-
-            let client = reqwest::Client::builder()
-                .user_agent(format!(
-                    "gt-tools-autotest-agent{}",
-                    env!("CARGO_PKG_VERSION")
-                ))
-                .default_headers(headers)
-                .build()
-                .expect("Failed to build reqwest::Client.");
-
-            return Self {
-                server,
-                repo,
-                release_tag,
-                client
-            };
-        }
-    }
-
-    // Testing utils
-    fn match_release_by_tag(tag: &String, releases: Vec<Release>) -> Option<Release> {
-        let mut release: Option<Release> = None;
-        for rel in releases {
-            if rel.tag_name == *tag {
-                // Only store the value if one hasn't been stored already
-                if let Some(first_release) = &release {
-                    // if there was already a match, begin the error diagnostic creation.
-                    let first_id = first_release.id;
-                    let second_id = rel.id;
-                    assert!(
-                        first_id != second_id,
-                        "FAILURE: Found the same release ID twice while scanning for duplicate tags. How did we get the same one twice?"
-                    );
-                    eprintln!("ERROR: Two releases have been found for the tag \"{tag}\".");
-                    eprintln!("ERROR:    first ID: {first_id}");
-                    eprintln!("ERROR:    second ID: {second_id}");
-                    panic!("ERROR: Nonsense detected, I'm bailing out!");
-                } else {
-                    // else, store our first (and hopefully only) match
-                    release = Some(rel);
-                }
-            }
-        }
-        return release;
-    }
-}

src/main.rs

@@ -1,4 +1,5 @@
-use std::fs;
+
+use std::path;
 
 use gt_tool::cli::Args;
 use gt_tool::structs::release::{CreateReleaseOption, Release};
@@ -81,7 +82,8 @@ async fn main() -> Result<(), gt_tool::Error> {
 
             if let Some(release) = match_release_by_tag(&tag_name, release_candidates) {
                 for file in &files {
-                    match fs::exists(file) {
+                    let path = path::Path::new(&file);
+                    match path.try_exists() {
                         Ok(true) => continue,
                         Ok(false) => return Err(gt_tool::Error::NoSuchFile),
                         Err(e) => {