test(github): cover client request path and REST resource functions

src/github/actions.rs

@@ -87,4 +87,75 @@ mod tests {
         assert_eq!(with["inputs"]["env"], "prod");
         assert!(dispatch_body("main", None).get("inputs").is_none());
     }
+
+    use crate::github::test_support::{MockResponse, MockServer};
+
+    fn repo() -> RepoId {
+        RepoId {
+            owner: "o".into(),
+            repo: "r".into(),
+        }
+    }
+
+    #[test]
+    fn list_runs_unwraps_envelope_without_branch() {
+        let server = MockServer::start(vec![MockResponse::json(
+            200,
+            r#"{"workflow_runs":[{"id":1,"status":"completed","conclusion":"success","html_url":"u"}]}"#,
+        )]);
+        let client = server.client(None);
+        let runs = list_runs(&client, &repo(), None).unwrap();
+        assert_eq!(runs.len(), 1);
+        assert_eq!(
+            server.requests()[0].path,
+            "/repos/o/r/actions/runs?per_page=100&page=1"
+        );
+    }
+
+    #[test]
+    fn list_runs_appends_branch_query() {
+        let server = MockServer::start(vec![MockResponse::json(200, r#"{"workflow_runs":[]}"#)]);
+        let client = server.client(None);
+        list_runs(&client, &repo(), Some("feat/x")).unwrap();
+        assert_eq!(
+            server.requests()[0].path,
+            "/repos/o/r/actions/runs?branch=feat/x&per_page=100&page=1"
+        );
+    }
+
+    #[test]
+    fn get_run_fetches_single_run() {
+        let server = MockServer::start(vec![MockResponse::json(
+            200,
+            r#"{"id":7,"status":"completed","conclusion":"failure","html_url":"u"}"#,
+        )]);
+        let client = server.client(None);
+        let run = get_run(&client, &repo(), 7).unwrap();
+        assert_eq!(run.conclusion.as_deref(), Some("failure"));
+        assert_eq!(server.requests()[0].path, "/repos/o/r/actions/runs/7");
+    }
+
+    #[test]
+    fn rerun_posts_to_the_rerun_endpoint() {
+        let server = MockServer::start(vec![MockResponse::json(201, "")]);
+        let client = server.client(Some("tok"));
+        rerun(&client, &repo(), 9).unwrap();
+        let reqs = server.requests();
+        assert_eq!(reqs[0].method, "POST");
+        assert_eq!(reqs[0].path, "/repos/o/r/actions/runs/9/rerun");
+    }
+
+    #[test]
+    fn dispatch_posts_ref_to_workflow_dispatches() {
+        let server = MockServer::start(vec![MockResponse::json(204, "")]);
+        let client = server.client(Some("tok"));
+        dispatch(&client, &repo(), "ci.yml", "main", None).unwrap();
+        let reqs = server.requests();
+        assert_eq!(
+            reqs[0].path,
+            "/repos/o/r/actions/workflows/ci.yml/dispatches"
+        );
+        let sent: serde_json::Value = serde_json::from_str(&reqs[0].body).unwrap();
+        assert_eq!(sent["ref"], "main");
+    }
 }

src/github/client.rs

@@ -57,6 +57,18 @@ impl Client {
         }
     }
 
+    /// Construct a client aimed at an arbitrary base URL (e.g. a local mock
+    /// server) with an explicit token. Test-only: production code goes through
+    /// [`Client::new`] / [`Client::anonymous`], which always target GitHub.
+    #[cfg(test)]
+    pub(crate) fn for_test(base_url: String, token: Option<String>) -> Client {
+        Client {
+            agent: Self::agent(),
+            token,
+            base_url,
+        }
+    }
+
     pub fn request(
         &self,
         method: &str,
@@ -168,4 +180,81 @@ mod tests {
         assert!(as_array(&serde_json::json!({})).is_empty());
         assert!(as_array(&serde_json::Value::Null).is_empty());
     }
+
+    #[test]
+    fn map_status_429_is_rate_limited() {
+        assert!(matches!(
+            map_status(429, None, String::new()),
+            GitHubError::RateLimited(_)
+        ));
+    }
+
+    use crate::github::test_support::{MockResponse, MockServer};
+
+    #[test]
+    fn request_refuses_writes_without_a_token_before_any_network_call() {
+        // No server needed: the guard short-circuits before a request is made.
+        let client = Client::for_test("http://127.0.0.1:1".to_string(), None);
+        let err = client.request("POST", "/x", None).unwrap_err();
+        assert!(matches!(err, GitHubError::NoAuth(_)));
+    }
+
+    #[test]
+    fn request_get_parses_json_and_sends_expected_headers() {
+        let server = MockServer::start(vec![MockResponse::json(200, r#"{"ok":true}"#)]);
+        let client = server.client(None);
+        let value = client.request("GET", "/probe", None).unwrap();
+        assert_eq!(value["ok"], true);
+
+        let reqs = server.requests();
+        assert_eq!(reqs.len(), 1);
+        assert_eq!(reqs[0].method, "GET");
+        assert_eq!(reqs[0].path, "/probe");
+    }
+
+    #[test]
+    fn request_sends_json_body_on_writes() {
+        let server = MockServer::start(vec![MockResponse::json(201, r#"{"created":1}"#)]);
+        let client = server.client(Some("tok"));
+        let body = serde_json::json!({ "name": "value" });
+        let value = client.request("POST", "/thing", Some(body)).unwrap();
+        assert_eq!(value["created"], 1);
+
+        let reqs = server.requests();
+        assert_eq!(reqs[0].method, "POST");
+        let sent: serde_json::Value = serde_json::from_str(&reqs[0].body).unwrap();
+        assert_eq!(sent["name"], "value");
+    }
+
+    #[test]
+    fn request_empty_body_becomes_json_null() {
+        let server = MockServer::start(vec![MockResponse::json(204, "")]);
+        let client = server.client(Some("tok"));
+        let value = client
+            .request("POST", "/empty", Some(serde_json::json!({})))
+            .unwrap();
+        assert_eq!(value, serde_json::Value::Null);
+        let _ = server.requests();
+    }
+
+    #[test]
+    fn request_maps_error_status_from_the_wire() {
+        let server = MockServer::start(vec![
+            MockResponse::json(403, r#"{"message":"limited"}"#)
+                .with_header("x-ratelimit-remaining", "0"),
+        ]);
+        let client = server.client(Some("tok"));
+        let err = client.request("GET", "/limited", None).unwrap_err();
+        assert!(matches!(err, GitHubError::RateLimited(_)));
+        let _ = server.requests();
+    }
+
+    #[test]
+    fn request_reports_parse_error_on_malformed_json() {
+        let server = MockServer::start(vec![MockResponse::json(200, "not json")]);
+        let client = server.client(None);
+        let err = client.request("GET", "/bad", None).unwrap_err();
+        assert!(matches!(err, GitHubError::Parse(_)));
+        let _ = server.requests();
+    }
 }

src/github/identity.rs

@@ -79,4 +79,32 @@ mod tests {
     fn repo_id_parse_is_none_for_single_segment() {
         assert!(RepoId::parse("not-a-url").is_none());
     }
+
+    #[test]
+    fn normalize_repo_handles_ports_and_extra_path_segments() {
+        // ssh:// with an explicit port, and a deeper path than owner/repo.
+        assert_eq!(
+            normalize_repo("ssh://git@github.com:22/getappz/agentflare.git"),
+            "getappz/agentflare"
+        );
+        assert_eq!(
+            normalize_repo("https://gitlab.com/group/subgroup/proj.git"),
+            "subgroup/proj"
+        );
+    }
+
+    #[test]
+    fn normalize_repo_trims_trailing_slash_and_git_suffix() {
+        assert_eq!(normalize_repo("https://github.com/o/r.git/"), "o/r");
+    }
+
+    #[test]
+    fn normalize_repo_passes_through_a_bare_single_segment() {
+        assert_eq!(normalize_repo("justname"), "justname");
+    }
+
+    #[test]
+    fn repo_id_parse_is_none_for_empty_input() {
+        assert!(RepoId::parse("").is_none());
+    }
 }

src/github/issues.rs

@@ -112,4 +112,92 @@ mod tests {
         assert!(minimal.get("labels").is_none());
         assert!(minimal.get("assignees").is_none());
     }
+
+    use crate::github::test_support::{MockResponse, MockServer};
+
+    fn repo() -> RepoId {
+        RepoId {
+            owner: "o".into(),
+            repo: "r".into(),
+        }
+    }
+
+    #[test]
+    fn create_posts_to_issues() {
+        let server = MockServer::start(vec![MockResponse::json(
+            201,
+            r#"{"number":11,"html_url":"u","state":"open","title":"t"}"#,
+        )]);
+        let client = server.client(Some("tok"));
+        let issue = create(&client, &repo(), "t", None, &["bug".into()], &[]).unwrap();
+        assert_eq!(issue.number, 11);
+        let reqs = server.requests();
+        assert_eq!(reqs[0].path, "/repos/o/r/issues");
+        let sent: serde_json::Value = serde_json::from_str(&reqs[0].body).unwrap();
+        assert_eq!(sent["labels"][0], "bug");
+    }
+
+    #[test]
+    fn list_encodes_state() {
+        let server = MockServer::start(vec![MockResponse::json(
+            200,
+            r#"[{"number":1,"html_url":"u","state":"closed","title":"a"}]"#,
+        )]);
+        let client = server.client(None);
+        let issues = list(&client, &repo(), "closed").unwrap();
+        assert_eq!(issues.len(), 1);
+        assert_eq!(
+            server.requests()[0].path,
+            "/repos/o/r/issues?state=closed&per_page=100&page=1"
+        );
+    }
+
+    #[test]
+    fn get_fetches_single_issue() {
+        let server = MockServer::start(vec![MockResponse::json(
+            200,
+            r#"{"number":3,"html_url":"u","state":"open","title":"x"}"#,
+        )]);
+        let client = server.client(None);
+        let issue = get(&client, &repo(), 3).unwrap();
+        assert_eq!(issue.number, 3);
+        assert_eq!(server.requests()[0].path, "/repos/o/r/issues/3");
+    }
+
+    #[test]
+    fn comment_posts_body() {
+        let server = MockServer::start(vec![MockResponse::json(201, r#"{"id":1}"#)]);
+        let client = server.client(Some("tok"));
+        comment(&client, &repo(), 4, "hi").unwrap();
+        let reqs = server.requests();
+        assert_eq!(reqs[0].path, "/repos/o/r/issues/4/comments");
+        let sent: serde_json::Value = serde_json::from_str(&reqs[0].body).unwrap();
+        assert_eq!(sent["body"], "hi");
+    }
+
+    #[test]
+    fn close_patches_state_to_closed() {
+        let server = MockServer::start(vec![MockResponse::json(
+            200,
+            r#"{"number":6,"html_url":"u","state":"closed","title":"x"}"#,
+        )]);
+        let client = server.client(Some("tok"));
+        let issue = close(&client, &repo(), 6).unwrap();
+        assert_eq!(issue.state, "closed");
+        let reqs = server.requests();
+        assert_eq!(reqs[0].method, "PATCH");
+        let sent: serde_json::Value = serde_json::from_str(&reqs[0].body).unwrap();
+        assert_eq!(sent["state"], "closed");
+    }
+
+    #[test]
+    fn add_labels_posts_the_label_list() {
+        let server = MockServer::start(vec![MockResponse::json(200, "[]")]);
+        let client = server.client(Some("tok"));
+        add_labels(&client, &repo(), 2, &["a".into(), "b".into()]).unwrap();
+        let reqs = server.requests();
+        assert_eq!(reqs[0].path, "/repos/o/r/issues/2/labels");
+        let sent: serde_json::Value = serde_json::from_str(&reqs[0].body).unwrap();
+        assert_eq!(sent["labels"][1], "b");
+    }
 }

src/github/mod.rs

@@ -14,6 +14,9 @@ pub mod models;
 pub mod pulls;
 pub mod releases;
 
+#[cfg(test)]
+pub(crate) mod test_support;
+
 pub use client::Client;
 pub use identity::RepoId;
 
@@ -76,4 +79,43 @@ mod encode_tests {
         assert_eq!(encode_query("open"), "open");
         assert_eq!(encode_query("a b"), "a%20b");
     }
+
+    #[test]
+    fn encode_query_encodes_multibyte_utf8() {
+        // Each byte of a non-ASCII char is percent-encoded individually.
+        assert_eq!(encode_query("café"), "caf%C3%A9");
+    }
+
+    #[test]
+    fn github_error_display_matches_each_variant() {
+        assert_eq!(
+            GitHubError::NoAuth("no creds".into()).to_string(),
+            "no creds"
+        );
+        assert_eq!(
+            GitHubError::Forbidden("forbidden".into()).to_string(),
+            "forbidden"
+        );
+        assert_eq!(
+            GitHubError::RateLimited("slow down".into()).to_string(),
+            "slow down"
+        );
+        assert_eq!(GitHubError::NotFound.to_string(), "not found");
+        assert_eq!(
+            GitHubError::Http {
+                status: 500,
+                body: "boom".into()
+            }
+            .to_string(),
+            "GitHub HTTP 500: boom"
+        );
+        assert_eq!(
+            GitHubError::Transport("reset".into()).to_string(),
+            "transport error: reset"
+        );
+        assert_eq!(
+            GitHubError::Parse("bad json".into()).to_string(),
+            "response parse error: bad json"
+        );
+    }
 }