@mbe24/99problems 0.1.1 → 0.3.0

package/tests/integration.rs

@@ -1,22 +1,105 @@
-/// Integration tests — require a live GitHub API token.
-/// Run with: GITHUB_TOKEN=ghp_... cargo test -- --include-ignored
-///
-/// These tests use schemaorg/schemaorg#1842 as a known stable fixture.
-
+/// Integration tests — live network tests for GitHub + GitLab + Jira.
+/// Run with: cargo test -- --include-ignored
+/// Optional env vars for higher-rate/authenticated calls:
+/// - `GITHUB_TOKEN`=...
+/// - `GITLAB_TOKEN`=...
+/// - `JIRA_TOKEN`=...
+/// - `BITBUCKET_TOKEN`=...
+/// - `BITBUCKET_REPO`=`workspace/repo_slug`
+/// - `BITBUCKET_PR_ID`=numeric pull request id
 #[cfg(test)]
 mod tests {
-    use problems99::source::{Query, Source, github_issues::GitHubIssues};
+    use problems99::source::{
+        ContentKind, FetchRequest, FetchTarget, Source, bitbucket::BitbucketSource,
+        github::GitHubSource, gitlab::GitLabSource, jira::JiraSource,
+    };
+
+    fn github_token() -> Option<String> {
+        std::env::var("GITHUB_TOKEN").ok().or_else(|| {
+            problems99::config::Config::load_with_options(problems99::config::ResolveOptions {
+                instance: Some("github"),
+                ..problems99::config::ResolveOptions::default()
+            })
+            .ok()
+            .and_then(|c| c.token)
+        })
+    }
+
+    fn gitlab_token() -> Option<String> {
+        std::env::var("GITLAB_TOKEN").ok()
+    }
+
+    fn jira_token() -> Option<String> {
+        std::env::var("JIRA_TOKEN").ok()
+    }
+
+    fn bitbucket_token() -> Option<String> {
+        std::env::var("BITBUCKET_TOKEN").ok()
+    }
+
+    fn required_env(var: &str) -> String {
+        std::env::var(var).unwrap_or_else(|_| panic!("missing required env var: {var}"))
+    }
+
+    fn is_public_jira_login_wall(err: &str) -> bool {
+        err.contains("non-JSON content-type 'text/html'")
+            && (err.contains("auth/login page")
+                || err.contains("login.jsp?permissionViolation")
+                || err.contains("id-frontend.prod-east.frontend.public.atl-paas.net"))
+    }
+
+    fn fail_public_jira_login_wall(test_name: &str, msg: &str) -> ! {
+        panic!(
+            "{test_name}: public Jira endpoint returned a login/auth wall instead of JSON. \
+             This indicates external endpoint/auth drift (not an adapter parsing bug). \
+             Response details: {msg}"
+        )
+    }
 
-    fn token() -> Option<String> {
-        std::env::var("GITHUB_TOKEN").ok()
+    fn req_id(repo: &str, id: &str, include_review_comments: bool) -> FetchRequest {
+        FetchRequest {
+            target: FetchTarget::Id {
+                repo: repo.to_string(),
+                id: id.to_string(),
+                kind: ContentKind::Issue,
+                allow_fallback_to_pr: true,
+            },
+            per_page: 100,
+            token: github_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments,
+        }
+    }
+
+    fn req_id_with_kind(
+        repo: &str,
+        id: &str,
+        kind: ContentKind,
+        allow_fallback_to_pr: bool,
+    ) -> FetchRequest {
+        FetchRequest {
+            target: FetchTarget::Id {
+                repo: repo.to_string(),
+                id: id.to_string(),
+                kind,
+                allow_fallback_to_pr,
+            },
+            per_page: 100,
+            token: github_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments: false,
+        }
     }
 
     #[test]
     #[ignore = "requires GITHUB_TOKEN and live network"]
-    fn fetch_known_issue_1842() {
-        let source = GitHubIssues::new().unwrap();
-        let conv = source.fetch_one("schemaorg/schemaorg", 1842).unwrap();
-        assert_eq!(conv.id, 1842);
+    fn github_fetch_known_issue_1842() {
+        let source = GitHubSource::new().unwrap();
+        let req = req_id("schemaorg/schemaorg", "1842", false);
+        let conv = source.fetch(&req).unwrap().into_iter().next().unwrap();
+        assert_eq!(conv.id, "1842");
         assert_eq!(conv.title, "Online-only events");
         assert_eq!(conv.state, "closed");
         assert!(conv.body.is_some());
@@ -25,17 +108,19 @@ mod tests {
 
     #[test]
     #[ignore = "requires GITHUB_TOKEN and live network"]
-    fn search_returns_results() {
-        let source = GitHubIssues::new().unwrap();
-        let query = Query::build(
-            Some("is:issue state:closed EventSeries repo:schemaorg/schemaorg".into()),
-            None,
-            None,
-            None,
-            10,
-            token(),
-        );
-        let results = source.fetch(&query).unwrap();
+    fn github_search_returns_results() {
+        let source = GitHubSource::new().unwrap();
+        let req = FetchRequest {
+            target: FetchTarget::Search {
+                raw_query: "is:issue state:closed EventSeries repo:schemaorg/schemaorg".into(),
+            },
+            per_page: 10,
+            token: github_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments: false,
+        };
+        let results = source.fetch(&req).unwrap();
         assert!(!results.is_empty());
         for conv in &results {
             assert!(!conv.title.is_empty());
@@ -45,9 +130,10 @@ mod tests {
 
     #[test]
     #[ignore = "requires GITHUB_TOKEN and live network"]
-    fn fetch_one_comment_has_author_and_body() {
-        let source = GitHubIssues::new().unwrap();
-        let conv = source.fetch_one("schemaorg/schemaorg", 1842).unwrap();
+    fn github_fetch_one_comment_has_author_and_body() {
+        let source = GitHubSource::new().unwrap();
+        let req = req_id("schemaorg/schemaorg", "1842", false);
+        let conv = source.fetch(&req).unwrap().into_iter().next().unwrap();
         let first = conv
             .comments
             .first()
@@ -55,4 +141,298 @@ mod tests {
         assert!(first.author.is_some());
         assert!(!first.created_at.is_empty());
     }
+
+    #[test]
+    #[ignore = "requires GITHUB_TOKEN and live network"]
+    fn github_fetch_pr_2402_default_issue_comments_only() {
+        let source = GitHubSource::new().unwrap();
+        let req = req_id("github/gitignore", "2402", false);
+        let conv = source.fetch(&req).unwrap().into_iter().next().unwrap();
+
+        assert_eq!(conv.id, "2402");
+        assert!(!conv.title.is_empty());
+        assert!(!conv.state.is_empty());
+        assert!(!conv.comments.is_empty());
+        assert!(!conv.comments.iter().any(|c| {
+            c.kind.as_deref() == Some("review_comment")
+                || c.review_path.is_some()
+                || c.review_line.is_some()
+                || c.review_side.is_some()
+        }));
+    }
+
+    #[test]
+    #[ignore = "requires GITHUB_TOKEN and live network"]
+    fn github_fetch_pr_2402_with_review_comments() {
+        let source = GitHubSource::new().unwrap();
+        let req = req_id("github/gitignore", "2402", true);
+        let conv = source.fetch(&req).unwrap().into_iter().next().unwrap();
+
+        assert_eq!(conv.id, "2402");
+        assert!(
+            conv.comments
+                .iter()
+                .any(|c| c.kind.as_deref() == Some("review_comment"))
+        );
+        assert!(conv.comments.iter().any(|c| c.review_path.is_some()));
+    }
+
+    #[test]
+    #[ignore = "requires GITHUB_TOKEN and live network"]
+    fn github_search_pr_query_includes_2402() {
+        let source = GitHubSource::new().unwrap();
+        let req = FetchRequest {
+            target: FetchTarget::Search {
+                raw_query: "repo:github/gitignore is:pr 2402".into(),
+            },
+            per_page: 10,
+            token: github_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments: false,
+        };
+        let results = source.fetch(&req).unwrap();
+        assert!(!results.is_empty());
+        assert!(results.iter().any(|c| c.id == "2402"));
+    }
+
+    #[test]
+    #[ignore = "requires GITHUB_TOKEN and live network"]
+    fn github_fetch_issue_as_pr_errors_when_kind_is_explicit() {
+        let source = GitHubSource::new().unwrap();
+        let req = req_id_with_kind("schemaorg/schemaorg", "1842", ContentKind::Pr, false);
+        let err = source.fetch(&req).unwrap_err().to_string();
+        assert!(err.contains("not a pull request"));
+    }
+
+    #[test]
+    #[ignore = "requires GITHUB_TOKEN and live network"]
+    fn github_fetch_pr_as_issue_errors_when_fallback_is_disabled() {
+        let source = GitHubSource::new().unwrap();
+        let req = req_id_with_kind("github/gitignore", "2402", ContentKind::Issue, false);
+        let err = source.fetch(&req).unwrap_err().to_string();
+        assert!(err.contains("is a pull request"));
+    }
+
+    #[test]
+    #[ignore = "requires live network (GITLAB_TOKEN recommended for comments)"]
+    fn gitlab_fetch_issue_6() {
+        let source = GitLabSource::new(None).unwrap();
+        let req = FetchRequest {
+            target: FetchTarget::Id {
+                repo: "veloren/veloren".into(),
+                id: "6".into(),
+                kind: ContentKind::Issue,
+                allow_fallback_to_pr: true,
+            },
+            per_page: 50,
+            token: gitlab_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments: false,
+        };
+        let conv = source.fetch(&req).unwrap().into_iter().next().unwrap();
+        assert_eq!(conv.id, "6");
+        assert!(!conv.title.is_empty());
+    }
+
+    #[test]
+    #[ignore = "requires live network (GITLAB_TOKEN recommended for comments)"]
+    fn gitlab_fetch_mr_6() {
+        let source = GitLabSource::new(None).unwrap();
+        let req = FetchRequest {
+            target: FetchTarget::Id {
+                repo: "veloren/veloren".into(),
+                id: "6".into(),
+                kind: ContentKind::Pr,
+                allow_fallback_to_pr: false,
+            },
+            per_page: 50,
+            token: gitlab_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments: true,
+        };
+        let conv = source.fetch(&req).unwrap().into_iter().next().unwrap();
+        assert_eq!(conv.id, "6");
+        assert!(!conv.title.is_empty());
+    }
+
+    #[test]
+    #[ignore = "requires live network (GITLAB_TOKEN recommended for comments)"]
+    fn gitlab_search_issue_results() {
+        let source = GitLabSource::new(None).unwrap();
+        let req = FetchRequest {
+            target: FetchTarget::Search {
+                raw_query: "repo:veloren/veloren is:issue state:closed terrain".into(),
+            },
+            per_page: 10,
+            token: gitlab_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments: false,
+        };
+        let results = source.fetch(&req).unwrap();
+        assert!(!results.is_empty());
+    }
+
+    #[test]
+    #[ignore = "requires live network (GITLAB_TOKEN recommended for comments)"]
+    fn gitlab_search_mr_results() {
+        let source = GitLabSource::new(None).unwrap();
+        let req = FetchRequest {
+            target: FetchTarget::Search {
+                raw_query: "repo:veloren/veloren is:pr state:closed netcode".into(),
+            },
+            per_page: 10,
+            token: gitlab_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments: true,
+        };
+        let results = source.fetch(&req).unwrap();
+        assert!(!results.is_empty());
+    }
+
+    #[test]
+    #[ignore = "requires live network (public Jira endpoint)"]
+    fn jira_fetch_public_issue_cloud_12817() {
+        let source = JiraSource::new(Some("https://jira.atlassian.com".into())).unwrap();
+        let req = FetchRequest {
+            target: FetchTarget::Id {
+                repo: String::new(),
+                id: "CLOUD-12817".into(),
+                kind: ContentKind::Issue,
+                allow_fallback_to_pr: false,
+            },
+            per_page: 50,
+            token: jira_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments: false,
+        };
+        let conv = match source.fetch(&req) {
+            Ok(results) => results.into_iter().next().unwrap(),
+            Err(err) => {
+                let msg = err.to_string();
+                if is_public_jira_login_wall(&msg) {
+                    fail_public_jira_login_wall("jira_fetch_public_issue_cloud_12817", &msg);
+                }
+                panic!("unexpected Jira issue fetch error: {msg}");
+            }
+        };
+        assert_eq!(conv.id, "CLOUD-12817");
+        assert!(!conv.title.is_empty());
+    }
+
+    #[test]
+    #[ignore = "requires live network (public Jira endpoint)"]
+    fn jira_search_public_project() {
+        let source = JiraSource::new(Some("https://jira.atlassian.com".into())).unwrap();
+        let req = FetchRequest {
+            target: FetchTarget::Search {
+                raw_query: "repo:CLOUD state:closed CLOUD-12817".into(),
+            },
+            per_page: 5,
+            token: jira_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments: false,
+        };
+        let results = match source.fetch(&req) {
+            Ok(results) => results,
+            Err(err) => {
+                let msg = err.to_string();
+                if is_public_jira_login_wall(&msg) {
+                    fail_public_jira_login_wall("jira_search_public_project", &msg);
+                }
+                panic!("unexpected Jira search error: {msg}");
+            }
+        };
+        assert!(!results.is_empty());
+        assert!(results.iter().any(|c| c.id == "CLOUD-12817"));
+    }
+
+    #[test]
+    fn jira_rejects_pr_kind() {
+        let source = JiraSource::new(Some("https://jira.atlassian.com".into())).unwrap();
+        let req = FetchRequest {
+            target: FetchTarget::Id {
+                repo: String::new(),
+                id: "CLOUD-12817".into(),
+                kind: ContentKind::Pr,
+                allow_fallback_to_pr: false,
+            },
+            per_page: 5,
+            token: None,
+            account_email: None,
+            include_comments: true,
+            include_review_comments: false,
+        };
+        let err = source.fetch(&req).unwrap_err().to_string();
+        assert!(err.contains("does not support pull requests"));
+    }
+
+    #[test]
+    #[ignore = "requires live network and BITBUCKET_REPO/BITBUCKET_PR_ID env vars"]
+    fn bitbucket_cloud_fetch_pr_by_id() {
+        let source = BitbucketSource::new(None, Some("cloud".into())).unwrap();
+        let repo = required_env("BITBUCKET_REPO");
+        let pr_id = required_env("BITBUCKET_PR_ID");
+        let req = FetchRequest {
+            target: FetchTarget::Id {
+                repo,
+                id: pr_id.clone(),
+                kind: ContentKind::Pr,
+                allow_fallback_to_pr: false,
+            },
+            per_page: 50,
+            token: bitbucket_token(),
+            account_email: None,
+            include_comments: true,
+            include_review_comments: true,
+        };
+        let conv = source.fetch(&req).unwrap().into_iter().next().unwrap();
+        assert_eq!(conv.id, pr_id);
+        assert!(!conv.title.is_empty());
+    }
+
+    #[test]
+    #[ignore = "requires live network and BITBUCKET_REPO env var"]
+    fn bitbucket_cloud_search_pr_results() {
+        let source = BitbucketSource::new(None, Some("cloud".into())).unwrap();
+        let repo = required_env("BITBUCKET_REPO");
+        let req = FetchRequest {
+            target: FetchTarget::Search {
+                raw_query: format!("repo:{repo} is:pr state:all"),
+            },
+            per_page: 10,
+            token: bitbucket_token(),
+            account_email: None,
+            include_comments: false,
+            include_review_comments: false,
+        };
+        let results = source.fetch(&req).unwrap();
+        assert!(!results.is_empty());
+    }
+
+    #[test]
+    fn bitbucket_cloud_rejects_issue_kind() {
+        let source = BitbucketSource::new(None, Some("cloud".into())).unwrap();
+        let req = FetchRequest {
+            target: FetchTarget::Id {
+                repo: "workspace/repo".into(),
+                id: "1".into(),
+                kind: ContentKind::Issue,
+                allow_fallback_to_pr: false,
+            },
+            per_page: 10,
+            token: None,
+            account_email: None,
+            include_comments: false,
+            include_review_comments: false,
+        };
+        let err = source.fetch(&req).unwrap_err().to_string();
+        assert!(err.contains("supports pull requests only"));
+    }
 }

package/src/source/github_issues.rs

@@ -1,232 +0,0 @@
-use anyhow::{Result, anyhow};
-use reqwest::blocking::Client;
-use serde::Deserialize;
-
-use super::{Query, Source};
-use crate::model::{Comment, Conversation};
-
-pub struct GitHubIssues {
-    client: Client,
-}
-
-impl GitHubIssues {
-    pub fn new() -> Result<Self> {
-        let client = Client::builder()
-            .user_agent("99problems-cli/0.1.0")
-            .build()?;
-        Ok(Self { client })
-    }
-
-    fn auth_header(token: &Option<String>) -> Option<String> {
-        token.as_ref().map(|t| format!("Bearer {t}"))
-    }
-
-    fn get_pages<T: for<'de> Deserialize<'de>>(
-        &self,
-        url: &str,
-        token: &Option<String>,
-        per_page: u32,
-    ) -> Result<Vec<T>> {
-        let mut results = vec![];
-        let mut page = 1u32;
-
-        loop {
-            let mut req = self.client.get(url).query(&[
-                ("per_page", per_page.to_string()),
-                ("page", page.to_string()),
-            ]);
-
-            if let Some(auth) = Self::auth_header(token) {
-                req = req
-                    .header("Authorization", auth)
-                    .header("X-GitHub-Api-Version", "2022-11-28");
-            }
-
-            let resp = req.send()?;
-
-            if !resp.status().is_success() {
-                return Err(anyhow!(
-                    "GitHub API error {}: {}",
-                    resp.status(),
-                    resp.text()?
-                ));
-            }
-
-            let has_next = resp
-                .headers()
-                .get("link")
-                .and_then(|v| v.to_str().ok())
-                .map(|l| l.contains(r#"rel="next""#))
-                .unwrap_or(false);
-
-            let items: Vec<T> = resp.json()?;
-            let done = items.is_empty() || !has_next;
-            results.extend(items);
-            if done {
-                break;
-            }
-            page += 1;
-        }
-
-        Ok(results)
-    }
-}
-
-// --- GitHub API response shapes ---
-
-#[derive(Deserialize)]
-struct SearchResponse {
-    items: Vec<IssueItem>,
-}
-
-#[derive(Deserialize)]
-struct IssueItem {
-    number: u64,
-    title: String,
-    state: String,
-    body: Option<String>,
-}
-
-#[derive(Deserialize)]
-struct CommentItem {
-    user: Option<UserItem>,
-    created_at: String,
-    body: Option<String>,
-}
-
-#[derive(Deserialize)]
-struct UserItem {
-    login: String,
-}
-
-impl Source for GitHubIssues {
-    fn fetch(&self, query: &Query) -> Result<Vec<Conversation>> {
-        let search_url = "https://api.github.com/search/issues";
-        let mut page = 1u32;
-        let mut all_issues: Vec<IssueItem> = vec![];
-
-        loop {
-            let mut req = self.client.get(search_url).query(&[
-                ("q", query.raw.as_str()),
-                ("per_page", "100"),
-                ("page", &page.to_string()),
-            ]);
-
-            if let Some(auth) = Self::auth_header(&query.token) {
-                req = req
-                    .header("Authorization", auth)
-                    .header("X-GitHub-Api-Version", "2022-11-28");
-            }
-
-            let resp = req.send()?;
-            if !resp.status().is_success() {
-                return Err(anyhow!(
-                    "GitHub search error {}: {}",
-                    resp.status(),
-                    resp.text()?
-                ));
-            }
-
-            let search: SearchResponse = resp.json()?;
-            let done = search.items.len() < 100;
-            all_issues.extend(search.items);
-            if done {
-                break;
-            }
-            page += 1;
-        }
-
-        // Determine repo from query for comment fetching
-        let repo = extract_repo(&query.raw).ok_or_else(|| {
-            anyhow!("No repo: found in query. Use --repo or include 'repo:owner/name' in -q")
-        })?;
-
-        let mut conversations = vec![];
-        for issue in all_issues {
-            let comments_url = format!(
-                "https://api.github.com/repos/{repo}/issues/{}/comments",
-                issue.number
-            );
-            let raw_comments: Vec<CommentItem> =
-                self.get_pages(&comments_url, &query.token, 100)?;
-
-            conversations.push(Conversation {
-                id: issue.number,
-                title: issue.title,
-                state: issue.state,
-                body: issue.body,
-                comments: raw_comments
-                    .into_iter()
-                    .map(|c| Comment {
-                        author: c.user.map(|u| u.login),
-                        created_at: c.created_at,
-                        body: c.body,
-                    })
-                    .collect(),
-            });
-        }
-
-        Ok(conversations)
-    }
-
-    fn fetch_one(&self, repo: &str, issue_id: u64) -> Result<Conversation> {
-        let issue_url = format!("https://api.github.com/repos/{repo}/issues/{issue_id}");
-        let req = self.client.get(&issue_url);
-        // token is not stored on struct, so we pass None here — callers set it via Query
-        // For fetch_one we skip auth (public repos). Callers who need auth should use fetch().
-        let resp = req.send()?;
-        if !resp.status().is_success() {
-            return Err(anyhow!(
-                "GitHub issue error {}: {}",
-                resp.status(),
-                resp.text()?
-            ));
-        }
-        let issue: IssueItem = resp.json()?;
-
-        let comments_url =
-            format!("https://api.github.com/repos/{repo}/issues/{issue_id}/comments");
-        let raw_comments: Vec<CommentItem> = self.get_pages(&comments_url, &None, 100)?;
-
-        Ok(Conversation {
-            id: issue.number,
-            title: issue.title,
-            state: issue.state,
-            body: issue.body,
-            comments: raw_comments
-                .into_iter()
-                .map(|c| Comment {
-                    author: c.user.map(|u| u.login),
-                    created_at: c.created_at,
-                    body: c.body,
-                })
-                .collect(),
-        })
-    }
-}
-
-/// Extract `owner/repo` from a query string containing `repo:owner/repo`.
-pub fn extract_repo(query: &str) -> Option<String> {
-    query
-        .split_whitespace()
-        .find(|t| t.starts_with("repo:"))
-        .map(|t| t.trim_start_matches("repo:").to_string())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn extract_repo_finds_token() {
-        assert_eq!(
-            extract_repo("is:issue state:closed repo:owner/repo Event"),
-            Some("owner/repo".into())
-        );
-    }
-
-    #[test]
-    fn extract_repo_returns_none_when_absent() {
-        assert_eq!(extract_repo("is:issue state:closed Event"), None);
-    }
-}