use async_trait::async_trait;
use gitflow_core::{
CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
issue::{CreateIssueArgs, EditIssueArgs, IssueData, IssueProvider, ListIssueArgs},
types::{CommentData, Label, State, UserSummary},
};
use tracing::debug;
use crate::{
GITHUB_API_MAX_PER_PAGE,
datetime::parse_api_datetime,
error::parse_gh_error,
runner::{CommandRunner, RealCommandRunner},
};
const ISSUE_FIELDS: &str =
"number,title,body,state,labels,author,assignees,createdAt,updatedAt,milestone,url";
#[derive(Debug, Clone)]
pub struct GitHubIssueProvider<R: CommandRunner = RealCommandRunner> {
repo: String,
runner: R,
}
impl GitHubIssueProvider<RealCommandRunner> {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
Self {
repo: repo.into(),
runner: RealCommandRunner,
}
}
#[must_use]
pub fn with_session(session: &gitflow_core::Session) -> Self {
Self {
repo: session.repo.clone(),
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitHubIssueProvider<R> {
#[must_use]
pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
Self {
repo: repo.into(),
runner,
}
}
async fn ensure_label_exists(&self, name: &str) -> Result<()> {
debug!(repo = %self.repo, name, "auto-creating missing label via `gh label create`");
let output = self
.runner
.run(
"gh",
&[
"label", "create", name, "--color", "ededed", "--repo", &self.repo, "--force",
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh label create: {e}")))?;
if !output.status.success() {
let mut gh_err = parse_gh_error(&output.stderr);
gh_err.user_message = format!("自动创建标签 '{name}' 失败:{}", gh_err.user_message);
return Err(gh_err.into());
}
Ok(())
}
}
impl<R: CommandRunner + Clone + 'static> GitHubIssueProvider<R> {
async fn list_impl(&self, args: ListIssueArgs) -> Result<Paged<IssueData>> {
let cap = args.limit.unwrap_or(DEFAULT_LIST_LIMIT);
let state = args.state.map(|state| match state {
State::Open => "open",
State::Closed => "closed",
State::All => "all",
});
let repo = &self.repo;
let runner = &self.runner;
let search = &args.search;
let labels = &args.labels;
let milestone = &args.milestone;
debug!(repo = %self.repo, cap, "spawning `gh issue list`");
fetch_capped(FetchStrategy::SingleShot, cap, |_page, limit| async move {
let limit_str = limit.to_string();
let mut cmd_args: Vec<&str> =
vec!["issue", "list", "--repo", repo, "--json", ISSUE_FIELDS];
if let Some(state) = state {
cmd_args.push("--state");
cmd_args.push(state);
}
if let Some(search) = search {
cmd_args.push("--search");
cmd_args.push(search);
}
for label in labels {
cmd_args.push("--label");
cmd_args.push(label);
}
let resolved_milestone_title;
if let Some(identifier) = milestone {
let milestone_provider =
crate::GitHubMilestoneProvider::with_runner(repo.as_str(), runner.clone());
let resolved = gitflow_core::label::resolve_milestone_identifier(
&milestone_provider,
identifier,
)
.await?;
resolved_milestone_title = resolved.title;
cmd_args.push("--milestone");
cmd_args.push(&resolved_milestone_title);
}
cmd_args.push("--limit");
cmd_args.push(&limit_str);
let output = runner
.run("gh", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let issues: Vec<IssueData> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(issues)
})
.await
}
}
#[async_trait]
impl<R: CommandRunner + Clone + 'static> IssueProvider for GitHubIssueProvider<R> {
async fn create(&self, args: CreateIssueArgs) -> Result<IssueData> {
let labels_joined = args.labels.join(",");
let assignees_joined = args.assignees.join(",");
let mut cmd_args: Vec<&str> = vec![
"issue",
"create",
"--repo",
&self.repo,
"--title",
&args.title,
];
if let Some(body) = &args.body {
cmd_args.push("--body");
cmd_args.push(body);
}
if !args.labels.is_empty() {
cmd_args.push("--label");
cmd_args.push(&labels_joined);
}
if !args.assignees.is_empty() {
cmd_args.push("--assignee");
cmd_args.push(&assignees_joined);
}
let resolved_milestone_title;
if let Some(identifier) = &args.milestone {
let milestone_provider = crate::GitHubMilestoneProvider::with_runner(
self.repo.as_str(),
self.runner.clone(),
);
let resolved =
gitflow_core::label::resolve_milestone_identifier(&milestone_provider, identifier)
.await?;
resolved_milestone_title = resolved.title;
cmd_args.push("--milestone");
cmd_args.push(&resolved_milestone_title);
}
debug!(repo = %self.repo, title = %args.title, "spawning `gh issue create`");
let output = self
.runner
.run("gh", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
let missing = extract_missing_labels_from_error(&output.stderr);
if !missing.is_empty() {
debug!(
repo = %self.repo,
missing_count = missing.len(),
"auto-creating missing label(s) before retrying issue create"
);
for label in &missing {
self.ensure_label_exists(label).await?;
}
let retry_output = self.runner.run("gh", &cmd_args).await.map_err(|e| {
CoreError::Platform(format!("Failed to spawn gh on retry: {e}"))
})?;
if !retry_output.status.success() {
return Err(parse_gh_error(&retry_output.stderr).into());
}
let stdout = String::from_utf8_lossy(&retry_output.stdout);
let issue_number = parse_issue_number_from_url(&stdout).ok_or_else(|| {
CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
})?;
return self.view(issue_number).await;
}
return Err(parse_gh_error(&output.stderr).into());
}
let stdout = String::from_utf8_lossy(&output.stdout);
let issue_number = parse_issue_number_from_url(&stdout).ok_or_else(|| {
CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
})?;
self.view(issue_number).await
}
async fn edit(&self, number: u64, args: EditIssueArgs) -> Result<IssueData> {
debug!(repo = %self.repo, number, "spawning `gh issue edit`");
let number_str = number.to_string();
let mut cmd_args: Vec<&str> = vec!["issue", "edit", &number_str, "--repo", &self.repo];
if let Some(title) = &args.title {
cmd_args.push("--title");
cmd_args.push(title);
}
if let Some(body) = &args.body {
cmd_args.push("--body");
cmd_args.push(body);
}
let resolved_milestone_title;
match &args.milestone {
None => {}
Some(None) => {
cmd_args.push("--remove-milestone");
}
Some(Some(identifier)) => {
let milestone_provider = crate::GitHubMilestoneProvider::with_runner(
self.repo.as_str(),
self.runner.clone(),
);
let resolved = gitflow_core::label::resolve_milestone_identifier(
&milestone_provider,
identifier,
)
.await?;
resolved_milestone_title = resolved.title;
cmd_args.push("--milestone");
cmd_args.push(&resolved_milestone_title);
}
}
let output = self
.runner
.run("gh", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
self.view(number).await
}
async fn list(&self, args: ListIssueArgs) -> Result<Paged<IssueData>> {
self.list_impl(args).await
}
async fn view(&self, number: u64) -> Result<IssueData> {
debug!(repo = %self.repo, number, "spawning `gh issue view`");
let number_str = number.to_string();
let output = self
.runner
.run(
"gh",
&[
"issue",
"view",
&number_str,
"--repo",
&self.repo,
"--json",
ISSUE_FIELDS,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let issue: IssueData =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(issue)
}
async fn close(&self, number: u64) -> Result<IssueData> {
debug!(repo = %self.repo, number, "spawning `gh api issues PATCH state=closed`");
let api_path = format!("repos/{repo}/issues/{number}", repo = self.repo);
let output = self
.runner
.run(
"gh",
&["api", &api_path, "-X", "PATCH", "-f", "state=closed"],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh api issue close: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let api_response: GitHubIssueApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_response.into())
}
async fn reopen(&self, number: u64) -> Result<IssueData> {
debug!(repo = %self.repo, number, "spawning `gh api issues PATCH state=open`");
let api_path = format!("repos/{repo}/issues/{number}", repo = self.repo);
let output = self
.runner
.run("gh", &["api", &api_path, "-X", "PATCH", "-f", "state=open"])
.await
.map_err(|e| {
CoreError::Platform(format!("Failed to spawn gh api issue reopen: {e}"))
})?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let api_response: GitHubIssueApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_response.into())
}
async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
debug!(repo = %self.repo, number, "spawning `gh api` POST to create issue comment");
let api_path = format!(
"repos/{repo}/issues/{number}/comments",
repo = self.repo,
number = number
);
let body_field = format!("body={body}");
let output = self
.runner
.run("gh", &["api", &api_path, "-X", "POST", "-f", &body_field])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh api: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let comment: GitHubCommentApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(comment.into())
}
async fn list_comments(&self, number: u64, limit: Option<u32>) -> Result<Paged<CommentData>> {
let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
let repo = &self.repo;
let runner = &self.runner;
debug!(repo = %self.repo, number, cap, "spawning `gh api` GET issue comments");
fetch_capped(
FetchStrategy::Paged {
per_page: cap.saturating_add(1).min(GITHUB_API_MAX_PER_PAGE),
},
cap,
|page, per_page| async move {
let api_path = format!(
"repos/{repo}/issues/{number}/comments?per_page={per_page}&page={page}"
);
let output = runner
.run("gh", &["api", &api_path])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh api: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
let comments: Vec<GitHubCommentApiResponse> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(comments.into_iter().map(CommentData::from).collect())
},
)
.await
}
async fn add_labels(&self, number: u64, labels: &[String]) -> Result<()> {
debug!(
repo = %self.repo,
number,
label_count = labels.len(),
"spawning `gh issue edit --add-label`"
);
let number_str = number.to_string();
let mut cmd_args: Vec<&str> = vec!["issue", "edit", &number_str, "--repo", &self.repo];
for label in labels {
cmd_args.push("--add-label");
cmd_args.push(label);
}
let output = self
.runner
.run("gh", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if output.status.success() {
return Ok(());
}
let missing = extract_missing_labels_from_error(&output.stderr);
if missing.is_empty() {
return Err(parse_gh_error(&output.stderr).into());
}
debug!(
repo = %self.repo,
missing_count = missing.len(),
"auto-creating missing label(s) before retry"
);
for label in &missing {
self.ensure_label_exists(label).await?;
}
let retry_output = self
.runner
.run("gh", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh on retry: {e}")))?;
if !retry_output.status.success() {
return Err(parse_gh_error(&retry_output.stderr).into());
}
Ok(())
}
async fn remove_label(&self, number: u64, label: &str) -> Result<()> {
debug!(repo = %self.repo, number, label, "spawning `gh issue edit --remove-label`");
let number_str = number.to_string();
let output = self
.runner
.run(
"gh",
&[
"issue",
"edit",
&number_str,
"--repo",
&self.repo,
"--remove-label",
label,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn gh: {e}")))?;
if !output.status.success() {
return Err(parse_gh_error(&output.stderr).into());
}
Ok(())
}
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct GitHubCommentApiResponse {
pub id: u64,
pub body: String,
pub user: GitHubUser,
pub created_at: String,
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct GitHubLabelApiResponse {
pub name: String,
#[serde(default)]
pub color: Option<String>,
#[serde(default)]
pub description: Option<String>,
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct GitHubIssueApiResponse {
pub number: u64,
pub title: String,
#[serde(default)]
pub body: Option<String>,
pub state: State,
#[serde(default)]
pub labels: Vec<GitHubLabelApiResponse>,
pub user: GitHubUser,
#[serde(default)]
pub assignees: Vec<GitHubUser>,
pub created_at: String,
pub updated_at: String,
pub html_url: String,
#[serde(default)]
pub milestone: Option<gitflow_core::types::MilestoneRef>,
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct GitHubUser {
pub login: String,
pub id: u64,
}
impl From<GitHubCommentApiResponse> for CommentData {
fn from(api: GitHubCommentApiResponse) -> Self {
Self {
id: api.id,
body: api.body,
author: gitflow_core::types::UserSummary {
login: api.user.login,
id: api.user.id.to_string(),
},
created_at: Some(parse_api_datetime(&api.created_at)),
}
}
}
impl From<GitHubLabelApiResponse> for Label {
fn from(api: GitHubLabelApiResponse) -> Self {
Self {
name: api.name,
color: api.color,
description: api.description,
}
}
}
impl From<GitHubUser> for UserSummary {
fn from(user: GitHubUser) -> Self {
Self {
login: user.login,
id: user.id.to_string(),
}
}
}
impl From<GitHubIssueApiResponse> for IssueData {
fn from(api: GitHubIssueApiResponse) -> Self {
Self {
number: api.number,
title: api.title,
body: api.body,
state: api.state,
labels: api.labels.into_iter().map(Label::from).collect(),
author: api.user.into(),
assignees: api.assignees.into_iter().map(UserSummary::from).collect(),
created_at: Some(parse_api_datetime(&api.created_at)),
updated_at: Some(parse_api_datetime(&api.updated_at)),
url: api.html_url,
milestone: api.milestone,
}
}
}
fn parse_issue_number_from_url(url: &str) -> Option<u64> {
url.lines().find_map(|line| {
let line = line.trim();
if line.contains("/issues/") {
line.rsplit("/issues/")
.next()
.and_then(|s| s.split('/').next())
.and_then(|s| s.parse().ok())
} else {
None
}
})
}
fn extract_missing_labels_from_error(stderr: &[u8]) -> Vec<String> {
let text = String::from_utf8_lossy(stderr);
let mut labels = Vec::new();
let mut search_from: usize = 0;
while let Some(rel_open) = text[search_from..].find('\'') {
let open_pos = search_from + rel_open + 1; let Some(rel_close) = text[open_pos..].find('\'') else {
break; };
let close_pos = open_pos + rel_close;
let after_close = &text[close_pos + 1..];
if after_close.starts_with(" not found") {
let label = text[open_pos..close_pos].to_string();
if !label.is_empty() {
labels.push(label);
}
}
search_from = close_pos + 1;
}
labels
}
#[cfg(test)]
mod tests {
use gitflow_core::types::UserSummary;
use super::*;
use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
#[test]
fn test_should_construct_github_issue_provider() {
let provider = GitHubIssueProvider::new("octocat/hello-world");
assert_eq!(provider.repo, "octocat/hello-world");
}
#[test]
fn test_should_construct_github_issue_provider_from_string() {
let repo = String::from("octocat/hello-world");
let provider = GitHubIssueProvider::new(repo);
assert_eq!(provider.repo, "octocat/hello-world");
}
#[test]
fn test_should_deserialize_issue_data_from_gh_output() {
let gh_json = br#"{
"number": 42,
"title": "Fix login bug",
"body": "Reproduced on v1.2.3",
"state": "open",
"labels": [
{"name": "bug", "color": "d73a4a", "description": "Something isn't working"}
],
"author": {"login": "octocat", "id": "1"},
"assignees": [{"login": "alice", "id": "7"}],
"createdAt": "2026-01-15T09:30:00Z",
"updatedAt": "2026-01-16T11:00:00Z",
"url": "https://github.com/octocat/hello-world/issues/42"
}"#;
let issue: IssueData = serde_json::from_slice(gh_json).expect("valid IssueData JSON");
assert_eq!(issue.number, 42);
assert_eq!(issue.title, "Fix login bug");
assert_eq!(issue.state, State::Open);
assert_eq!(issue.labels.len(), 1);
assert_eq!(issue.author.login, "octocat");
assert_eq!(issue.assignees.len(), 1);
assert_eq!(
issue.url,
"https://github.com/octocat/hello-world/issues/42"
);
}
#[test]
fn test_should_deserialize_issue_with_milestone() {
let gh_json = br#"{
"number": 42,
"title": "Test",
"body": null,
"state": "OPEN",
"labels": [],
"author": {"login": "octocat", "id": "1"},
"assignees": [],
"createdAt": "2026-01-01T00:00:00Z",
"updatedAt": "2026-01-01T00:00:00Z",
"milestone": {"number": 3, "title": "v2.0"},
"url": "https://github.com/octocat/hello-world/issues/42"
}"#;
let issue: IssueData = serde_json::from_slice(gh_json).expect("valid IssueData JSON");
assert_eq!(
issue.milestone,
Some(gitflow_core::types::MilestoneRef {
number: 3,
title: "v2.0".into()
})
);
}
#[test]
fn test_should_deserialize_issue_with_no_milestone() {
let gh_json = br#"{
"number": 42,
"title": "Test",
"body": null,
"state": "OPEN",
"labels": [],
"author": {"login": "octocat", "id": "1"},
"assignees": [],
"createdAt": "2026-01-01T00:00:00Z",
"updatedAt": "2026-01-01T00:00:00Z",
"url": "https://github.com/octocat/hello-world/issues/42"
}"#;
let issue: IssueData = serde_json::from_slice(gh_json).expect("valid IssueData JSON");
assert!(issue.milestone.is_none());
}
#[test]
fn test_should_deserialize_empty_issue_list_from_gh_output() {
let gh_json = b"[]";
let issues: Vec<IssueData> = serde_json::from_slice(gh_json).expect("valid IssueData list");
assert!(issues.is_empty());
}
#[test]
fn test_should_debug_format_provider() {
let provider = GitHubIssueProvider::new("octocat/hello-world");
let debug = format!("{provider:?}");
assert!(debug.contains("GitHubIssueProvider"));
assert!(debug.contains("octocat/hello-world"));
}
#[test]
fn test_should_deserialize_closed_issue_from_gh_close_output() {
let gh_json = br#"{
"number": 10,
"title": "Fixed typo",
"body": null,
"state": "closed",
"labels": [],
"author": {"login": "dev", "id": "5"},
"assignees": [],
"createdAt": "2026-06-01T08:00:00Z",
"updatedAt": "2026-06-02T12:00:00Z",
"url": "https://github.com/octocat/hello-world/issues/10"
}"#;
let issue: IssueData = serde_json::from_slice(gh_json).expect("valid closed IssueData");
assert_eq!(issue.number, 10);
assert_eq!(issue.state, State::Closed);
assert_eq!(issue.title, "Fixed typo");
}
#[test]
fn test_should_deserialize_reopened_issue_from_gh_reopen_output() {
let gh_json = br#"{
"number": 10,
"title": "Fixed typo",
"body": null,
"state": "open",
"labels": [],
"author": {"login": "dev", "id": "5"},
"assignees": [],
"createdAt": "2026-06-01T08:00:00Z",
"updatedAt": "2026-06-03T09:00:00Z",
"url": "https://github.com/octocat/hello-world/issues/10"
}"#;
let issue: IssueData = serde_json::from_slice(gh_json).expect("valid reopened IssueData");
assert_eq!(issue.number, 10);
assert_eq!(issue.state, State::Open);
}
#[test]
fn test_should_deserialize_comment_data_from_gh_comment_output() {
let gh_json = br#"{
"id": 1001,
"body": "Thanks for reporting, looking into it.",
"author": {"login": "maintainer", "id": "42"},
"createdAt": "2026-06-15T14:00:00Z"
}"#;
let comment: CommentData = serde_json::from_slice(gh_json).expect("valid CommentData");
assert_eq!(comment.id, 1001);
assert_eq!(comment.body, "Thanks for reporting, looking into it.");
assert_eq!(comment.author.login, "maintainer");
assert_eq!(comment.author.id, "42");
}
#[test]
fn test_should_roundtrip_comment_data_via_serde() {
let comment = CommentData {
id: 77,
body: "reviewed".into(),
author: UserSummary {
login: "alice".into(),
id: "3".to_string(),
},
created_at: Some("2026-05-01T00:00:00Z".parse().expect("valid date")),
};
let json = serde_json::to_string(&comment).expect("serialize");
let round_tripped: CommentData = serde_json::from_str(&json).expect("deserialize");
assert_eq!(round_tripped.id, comment.id);
assert_eq!(round_tripped.body, comment.body);
assert_eq!(round_tripped.author.login, comment.author.login);
}
#[test]
fn test_should_convert_github_api_response_to_comment_data() {
let api_response = GitHubCommentApiResponse {
id: 12345,
body: "Test comment body".to_string(),
user: GitHubUser {
login: "testuser".to_string(),
id: 42,
},
created_at: "2026-07-08T10:30:00Z".to_string(),
};
let comment_data: CommentData = api_response.into();
assert_eq!(comment_data.id, 12345);
assert_eq!(comment_data.body, "Test comment body");
assert_eq!(comment_data.author.login, "testuser");
assert_eq!(comment_data.author.id, "42");
}
#[test]
fn test_should_handle_invalid_date_in_api_response() {
let api_response = GitHubCommentApiResponse {
id: 1,
body: "test".to_string(),
user: GitHubUser {
login: "user".to_string(),
id: 1,
},
created_at: "invalid-date".to_string(),
};
let comment_data: CommentData = api_response.into();
assert_eq!(comment_data.created_at, Some(chrono::DateTime::UNIX_EPOCH));
}
fn sample_rest_issue_response() -> GitHubIssueApiResponse {
serde_json::from_str(REST_CLOSED_ISSUE_JSON).expect("fixture must deserialize")
}
#[test]
fn test_should_convert_rest_issue_response_to_issue_data() {
let issue: IssueData = sample_rest_issue_response().into();
assert_eq!(issue.number, 107);
assert_eq!(issue.title, "upstream CLI 新版本: glab 1.111.0");
assert_eq!(issue.body, None);
assert_eq!(issue.state, State::Closed);
assert_eq!(issue.author.login, "github-actions[bot]");
assert_eq!(issue.author.id, "41898282");
assert_eq!(issue.labels.len(), 1);
assert_eq!(issue.labels[0].name, "upstream-drift");
assert_eq!(
issue.labels[0].color.as_deref(),
Some("ededed"),
"REST label colors must keep the API-provided hex value"
);
assert_eq!(issue.labels[0].description, None);
assert!(issue.assignees.is_empty());
assert_eq!(issue.url, "https://github.com/o/r/issues/107");
}
#[test]
fn test_should_deserialize_issue_with_present_timestamps_as_some() {
let issue: IssueData = sample_rest_issue_response().into();
assert!(issue.created_at.is_some());
assert!(issue.updated_at.is_some());
}
#[test]
fn test_should_fall_back_to_epoch_for_invalid_rest_issue_dates() {
let mut api_response = sample_rest_issue_response();
api_response.created_at = "invalid-date".to_string();
api_response.updated_at = "also-invalid".to_string();
let issue: IssueData = api_response.into();
assert_eq!(issue.created_at, Some(chrono::DateTime::UNIX_EPOCH));
assert_eq!(issue.updated_at, Some(chrono::DateTime::UNIX_EPOCH));
}
#[test]
fn test_should_create_provider_with_different_repos() {
let r1 = GitHubIssueProvider::new("org/repo-a");
let r2 = GitHubIssueProvider::new("org/repo-b");
assert_eq!(r1.repo, "org/repo-a");
assert_eq!(r2.repo, "org/repo-b");
}
#[test]
fn test_should_clone_github_issue_provider() {
let original = GitHubIssueProvider::new("owner/repo");
let cloned = original.clone();
assert_eq!(original.repo, cloned.repo);
}
#[test]
fn test_should_parse_issue_number_from_github_url() {
assert_eq!(
parse_issue_number_from_url("https://github.com/owner/repo/issues/123"),
Some(123)
);
}
#[test]
fn test_should_parse_issue_number_from_enterprise_url() {
assert_eq!(
parse_issue_number_from_url("https://github.enterprise.com/org/project/issues/456"),
Some(456)
);
}
#[test]
fn test_should_parse_issue_number_from_multiline_output() {
let output = "Creating issue...\nhttps://github.com/owner/repo/issues/789\nDone.";
assert_eq!(parse_issue_number_from_url(output), Some(789));
}
#[test]
fn test_should_return_none_for_invalid_url() {
assert_eq!(parse_issue_number_from_url("not a url"), None);
}
#[test]
fn test_should_return_none_for_url_without_number() {
assert_eq!(
parse_issue_number_from_url("https://github.com/owner/repo/issues/"),
None
);
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_view() {
let runner = MockCommandRunner::failure(r#"{"message": "Issue not found"}"#, 256);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.view(999).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_view() {
let runner = MockCommandRunner::success("not valid json");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.view(1).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_list() {
let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.list(ListIssueArgs::default()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_list() {
let runner = MockCommandRunner::success("invalid");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.list(ListIssueArgs::default()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
fn sample_create_args() -> CreateIssueArgs {
CreateIssueArgs {
title: "Bug report".to_string(),
body: Some("Steps to reproduce".to_string()),
labels: vec!["bug".to_string()],
assignees: vec!["octocat".to_string()],
milestone: None,
}
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_create() {
let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_create_args()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_create() {
let runner = MockCommandRunner::success("https://github.com/owner/repo/issues/7");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.create(sample_create_args()).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_close() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.close(42).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_close() {
let runner = MockCommandRunner::success("invalid");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.close(42).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
const REST_CLOSED_ISSUE_JSON: &str = r#"{
"id": 5123456789,
"node_id": "I_kwDOXYZ",
"number": 107,
"title": "upstream CLI 新版本: glab 1.111.0",
"body": null,
"state": "closed",
"labels": [
{
"id": 7301464236,
"node_id": "LA_kwDOXYZ",
"url": "https://api.github.com/repos/o/r/labels/upstream-drift",
"name": "upstream-drift",
"color": "ededed",
"description": null,
"default": false
}
],
"user": {"login": "github-actions[bot]", "id": 41898282, "type": "Bot"},
"assignees": [],
"created_at": "2026-07-31T02:00:00Z",
"updated_at": "2026-08-03T09:31:29Z",
"closed_at": "2026-08-03T09:31:29Z",
"milestone": {"number": 3, "title": "v2.0", "state": "open", "id": 17970779},
"html_url": "https://github.com/o/r/issues/107"
}"#;
const REST_OPEN_ISSUE_JSON: &str = r#"{
"id": 5123456790,
"node_id": "I_kwDOXYZ2",
"number": 108,
"title": "upstream CLI 新版本: gitcode 0.8.0",
"body": "patrol report",
"state": "open",
"labels": [],
"user": {"login": "github-actions[bot]", "id": 41898282, "type": "Bot"},
"assignees": [{"login": "octocat", "id": 583231}],
"created_at": "2026-07-31T02:00:00Z",
"updated_at": "2026-08-03T06:20:18Z",
"closed_at": null,
"html_url": "https://github.com/o/r/issues/108"
}"#;
#[tokio::test]
async fn test_should_close_issue_via_single_api_patch_call() {
let runner = SequencedMockCommandRunner::from_results(&[(true, REST_CLOSED_ISSUE_JSON)]);
let provider = GitHubIssueProvider::with_runner("o/r", runner);
let issue = provider
.close(107)
.await
.expect("close must succeed with a single PATCH call");
assert_eq!(issue.number, 107);
assert_eq!(issue.state, State::Closed);
assert_eq!(issue.title, "upstream CLI 新版本: glab 1.111.0");
assert_eq!(issue.body, None);
assert_eq!(issue.author.login, "github-actions[bot]");
assert_eq!(issue.author.id, "41898282");
assert_eq!(issue.labels.len(), 1);
assert_eq!(issue.labels[0].name, "upstream-drift");
assert_eq!(issue.labels[0].description, None);
assert_eq!(issue.url, "https://github.com/o/r/issues/107");
assert_eq!(
issue.updated_at.map(|dt| dt.to_rfc3339()),
Some("2026-08-03T09:31:29+00:00".to_string())
);
assert_eq!(
issue.milestone,
Some(gitflow_core::types::MilestoneRef {
number: 3,
title: "v2.0".into(),
})
);
}
#[tokio::test]
async fn test_should_reopen_issue_via_single_api_patch_call() {
let runner = SequencedMockCommandRunner::from_results(&[(true, REST_OPEN_ISSUE_JSON)]);
let provider = GitHubIssueProvider::with_runner("o/r", runner);
let issue = provider
.reopen(108)
.await
.expect("reopen must succeed with a single PATCH call");
assert_eq!(issue.number, 108);
assert_eq!(issue.state, State::Open);
assert_eq!(issue.body.as_deref(), Some("patrol report"));
assert_eq!(issue.assignees.len(), 1);
assert_eq!(issue.assignees[0].login, "octocat");
assert_eq!(issue.assignees[0].id, "583231");
assert_eq!(issue.url, "https://github.com/o/r/issues/108");
assert_eq!(issue.milestone, None);
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_reopen() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.reopen(42).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_reopen() {
let runner = MockCommandRunner::success("invalid");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.reopen(42).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_comment() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.comment(42, "a comment").await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_serialization_error_on_invalid_json_for_comment() {
let runner = MockCommandRunner::success("invalid");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.comment(42, "a comment").await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Serialization(_)
));
}
#[tokio::test]
async fn test_should_return_newly_created_comment_not_stale() {
use crate::runner::MockCommandRunner;
let post_response_json = r#"{
"id": 9999999999,
"body": "This is the NEW comment",
"user": {"login": "testuser", "id": 42},
"created_at": "2026-08-04T12:00:00Z"
}"#;
let runner = MockCommandRunner::success(post_response_json);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider
.comment(42, "This is the NEW comment")
.await
.unwrap();
assert_eq!(result.id, 9_999_999_999);
assert_eq!(result.body, "This is the NEW comment");
assert_eq!(result.author.login, "testuser");
}
#[tokio::test]
async fn test_should_return_error_when_gh_api_post_fails() {
use crate::runner::MockCommandRunner;
let runner = MockCommandRunner::failure(
r#"{"message": "Issue not found", "documentation_url": "https://docs.github.com"}"#,
1,
);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.comment(999, "test").await;
assert!(result.is_err());
let err = result.unwrap_err();
assert!(
matches!(err, CoreError::Cli(_)),
"expected Cli error, got: {err:?}"
);
}
#[tokio::test]
async fn test_should_produce_complete_argv_for_list_comments_with_default_limit() {
let runner = MockCommandRunner::success("[]");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let paged = provider
.list_comments(359, None)
.await
.expect("list_comments should succeed");
assert!(paged.items.is_empty());
let calls = runner.recorded_calls();
assert_eq!(calls[0].0, "gh");
assert_eq!(
calls[0].1,
vec![
"api",
"repos/owner/repo/issues/359/comments?per_page=100&page=1"
]
);
}
#[tokio::test]
async fn test_should_build_well_formed_query_string_for_list_comments() {
let runner = MockCommandRunner::success("[]");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
provider
.list_comments(359, None)
.await
.expect("list_comments should succeed");
let calls = runner.recorded_calls();
let api_path = &calls[0].1[1];
assert_eq!(
api_path.matches('?').count(),
1,
"must have exactly one '?', got: {api_path}"
);
assert_eq!(
api_path.matches('&').count(),
1,
"must have exactly one '&', got: {api_path}"
);
assert!(api_path.contains("per_page=100"), "got: {api_path}");
assert!(api_path.contains("page=1"), "got: {api_path}");
}
#[tokio::test]
async fn test_should_increment_page_across_calls_for_list_comments() {
let full_page: Vec<String> = (0..100)
.map(|i| {
format!(
r#"{{"id":{i},"body":"c{i}","user":{{"login":"u","id":1}},"created_at":"2026-08-18T00:00:00Z"}}"#
)
})
.collect();
let full_page_json = format!("[{}]", full_page.join(","));
let short_page_json = r#"[{"id":9999,"body":"last","user":{"login":"u","id":1},"created_at":"2026-08-18T00:00:00Z"}]"#;
let runner = SequencedMockCommandRunner::from_results(&[
(true, &full_page_json),
(true, short_page_json),
]);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let paged = provider
.list_comments(359, Some(150))
.await
.expect("should list across two pages");
assert_eq!(paged.items.len(), 101);
let calls = runner.recorded_calls();
assert_eq!(calls.len(), 2, "必须恰好翻两页");
assert!(
calls[0].1[1].contains("page=1"),
"第一次调用必须请求 page=1,实际: {:?}",
calls[0].1
);
assert!(
calls[1].1[1].contains("page=2"),
"第二次调用必须请求 page=2,实际: {:?}",
calls[1].1
);
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_add_labels() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.add_labels(42, &["bug".to_string()]).await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_edit_issue_title_and_view_result() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, ""),
(
true,
r#"{"number":42,"title":"New title","body":"orig","state":"open","labels":[],"author":{"login":"octocat","id":"1"},"assignees":[],"createdAt":"2026-01-01T00:00:00Z","updatedAt":"2026-01-02T00:00:00Z","url":"https://github.com/owner/repo/issues/42"}"#,
),
]);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let issue = provider
.edit(
42,
gitflow_core::issue::EditIssueArgs {
title: Some("New title".to_string()),
body: None,
milestone: None,
},
)
.await
.expect("edit should succeed");
assert_eq!(issue.number, 42);
assert_eq!(issue.title, "New title");
}
#[tokio::test]
async fn test_should_send_only_provided_fields_for_edit() {
let runner = MockCommandRunner::success("");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let _ = provider
.edit(
7,
gitflow_core::issue::EditIssueArgs {
title: Some("T".to_string()),
body: None,
milestone: None,
},
)
.await;
assert_eq!(
runner.recorded_calls()[0].1,
vec!["issue", "edit", "7", "--repo", "owner/repo", "--title", "T"]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_edit() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider
.edit(42, gitflow_core::issue::EditIssueArgs::default())
.await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[tokio::test]
async fn test_should_return_platform_error_when_gh_fails_for_remove_label() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider.remove_label(42, "bug").await;
assert!(result.is_err());
assert!(matches!(
result.unwrap_err(),
gitflow_core::CoreError::Cli(_)
));
}
#[test]
fn test_should_extract_single_missing_label_from_gh_stderr() {
let stderr = b"failed to update https://github.com/owner/repo/issues/18: 'type:enhancement' not found\nfailed to update 1 issue";
let missing = extract_missing_labels_from_error(stderr);
assert_eq!(missing, vec!["type:enhancement".to_string()]);
}
#[test]
fn test_should_extract_multiple_missing_labels_from_gh_stderr() {
let stderr = b"failed to update https://github.com/owner/repo/issues/5: 'bug' not found, 'priority:high' not found\nfailed to update 1 issue";
let missing = extract_missing_labels_from_error(stderr);
assert_eq!(
missing,
vec!["bug".to_string(), "priority:high".to_string()]
);
}
#[test]
fn test_should_return_empty_when_no_label_not_found_in_stderr() {
let stderr = b"gh: Not logged in. Please run `gh auth login`";
let missing = extract_missing_labels_from_error(stderr);
assert!(missing.is_empty());
}
#[test]
fn test_should_return_empty_for_empty_stderr() {
let missing = extract_missing_labels_from_error(b"");
assert!(missing.is_empty());
}
#[test]
fn test_should_handle_label_with_special_characters() {
let stderr = b"failed to update https://github.com/o/r/issues/1: 'type: enhancement / bug' not found";
let missing = extract_missing_labels_from_error(stderr);
assert_eq!(missing, vec!["type: enhancement / bug".to_string()]);
}
#[tokio::test]
async fn test_should_auto_create_label_and_retry_on_not_found() {
let runner = SequencedMockCommandRunner::from_results(&[
(
false,
"failed to update https://github.com/owner/repo/issues/18: 'type:enhancement' not \
found\nfailed to update 1 issue",
),
(true, "Created label type:enhancement"),
(true, ""),
]);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider
.add_labels(18, &["type:enhancement".to_string()])
.await;
assert!(result.is_ok(), "expected Ok, got {result:?}");
}
#[tokio::test]
async fn test_should_auto_create_multiple_labels_and_retry() {
let runner = SequencedMockCommandRunner::from_results(&[
(
false,
"failed to update https://github.com/o/r/issues/5: 'bug' not found, \
'priority:high' not found\nfailed to update 1 issue",
),
(true, "Created label bug"),
(true, "Created label priority:high"),
(true, ""),
]);
let provider = GitHubIssueProvider::with_runner("o/r", runner);
let result = provider
.add_labels(5, &["bug".to_string(), "priority:high".to_string()])
.await;
assert!(result.is_ok(), "expected Ok, got {result:?}");
}
#[tokio::test]
async fn test_should_propagate_error_when_label_creation_fails() {
let runner = SequencedMockCommandRunner::from_results(&[
(
false,
"failed to update https://github.com/o/r/issues/1: 'ghost' not found",
),
(false, "gh: 403 Forbidden"),
]);
let provider = GitHubIssueProvider::with_runner("o/r", runner);
let result = provider.add_labels(1, &["ghost".to_string()]).await;
assert!(result.is_err());
let err = result.unwrap_err();
assert!(
matches!(err, gitflow_core::CoreError::Cli(_)),
"expected CoreError::Cli, got: {err:?}"
);
if let gitflow_core::CoreError::Cli(boxed) = err {
assert!(
boxed.raw_stderr.contains("403") || boxed.raw_stderr.contains("Forbidden"),
"unexpected raw_stderr: {}",
boxed.raw_stderr
);
}
}
#[tokio::test]
async fn test_should_not_retry_on_non_label_not_found_error() {
let runner = SequencedMockCommandRunner::from_results(&[(
false,
"gh: Not logged in. Please run `gh auth login`",
)]);
let provider = GitHubIssueProvider::with_runner("o/r", runner);
let result = provider.add_labels(1, &["bug".to_string()]).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_should_propagate_retry_error_when_second_add_also_fails() {
let runner = SequencedMockCommandRunner::from_results(&[
(
false,
"failed to update https://github.com/o/r/issues/1: 'bug' not found",
),
(true, "Created label bug"),
(false, "gh: 500 Internal Server Error"),
]);
let provider = GitHubIssueProvider::with_runner("o/r", runner);
let result = provider.add_labels(1, &["bug".to_string()]).await;
assert!(result.is_err());
let err = result.unwrap_err();
assert!(
matches!(err, gitflow_core::CoreError::Cli(_)),
"expected CoreError::Cli, got: {err:?}"
);
if let gitflow_core::CoreError::Cli(boxed) = err {
assert!(
boxed.raw_stderr.contains("500") || boxed.raw_stderr.contains("Internal"),
"unexpected raw_stderr: {}",
boxed.raw_stderr
);
}
}
fn create_args_with_labels(labels: Vec<String>) -> CreateIssueArgs {
CreateIssueArgs {
title: "New feature".to_string(),
body: Some("Description".to_string()),
labels,
assignees: vec![],
milestone: None,
}
}
#[tokio::test]
async fn test_should_auto_create_label_and_retry_on_create_issue() {
let runner = SequencedMockCommandRunner::from_results(&[
(false, "could not add label: 'type:enhancement' not found"),
(true, "Created label type:enhancement"),
(true, "https://github.com/owner/repo/issues/42"),
(
true,
r#"{"number":42,"title":"New feature","body":"Description","state":"open","labels":[{"name":"type:enhancement","color":"ededed"}],"author":{"login":"octocat","id":"1"},"assignees":[],"createdAt":"2026-01-01T00:00:00Z","updatedAt":"2026-01-01T00:00:00Z","url":"https://github.com/owner/repo/issues/42"}"#,
),
]);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let result = provider
.create(create_args_with_labels(vec![
"type:enhancement".to_string(),
]))
.await;
assert!(result.is_ok(), "expected Ok, got {result:?}");
let issue = result.expect("already checked");
assert_eq!(issue.number, 42);
}
#[tokio::test]
async fn test_should_propagate_error_when_label_create_fails_on_create_issue() {
let runner = SequencedMockCommandRunner::from_results(&[
(false, "could not add label: 'ghost' not found"),
(false, "gh: 403 Forbidden"),
]);
let provider = GitHubIssueProvider::with_runner("o/r", runner);
let result = provider
.create(create_args_with_labels(vec!["ghost".to_string()]))
.await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_should_not_retry_create_on_non_label_error() {
let runner = SequencedMockCommandRunner::from_results(&[(false, "gh: Not logged in")]);
let provider = GitHubIssueProvider::with_runner("o/r", runner);
let result = provider
.create(create_args_with_labels(vec!["bug".to_string()]))
.await;
assert!(result.is_err());
}
const MILESTONE_LIST_JSON: &str = r#"[
{"number": 3, "title": "v2.0", "state": "open", "description": null}
]"#;
#[tokio::test]
async fn test_should_wire_resolved_milestone_title_into_issue_create() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, MILESTONE_LIST_JSON),
(true, "https://github.com/owner/repo/issues/42"),
(
true,
r#"{"number":42,"title":"New feature","body":"Description","state":"open","labels":[],"author":{"login":"octocat","id":"1"},"assignees":[],"createdAt":"2026-01-01T00:00:00Z","updatedAt":"2026-01-01T00:00:00Z","milestone":{"number":3,"title":"v2.0"},"url":"https://github.com/owner/repo/issues/42"}"#,
),
]);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let mut args = create_args_with_labels(vec![]);
args.milestone = Some("3".to_string());
let issue = provider.create(args).await.expect("create should succeed");
assert_eq!(
issue.milestone,
Some(gitflow_core::types::MilestoneRef {
number: 3,
title: "v2.0".into()
})
);
let calls = runner.recorded_calls();
assert_eq!(calls.len(), 3, "expected exactly 3 gh invocations");
assert!(
calls[0].1.first().map(String::as_str) == Some("api"),
"first call must resolve the milestone via `gh api`, got: {:?}",
calls[0].1
);
let create_call = &calls[1].1;
assert!(
create_call
.windows(2)
.any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
"issue create argv must carry the resolved milestone title, got: {create_call:?}"
);
}
#[tokio::test]
async fn test_should_propagate_error_when_milestone_identifier_not_found_on_create() {
let runner = SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON)]);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let mut args = create_args_with_labels(vec![]);
args.milestone = Some("does-not-exist".to_string());
let result = provider.create(args).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_should_wire_resolved_milestone_title_into_issue_edit() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, MILESTONE_LIST_JSON),
(true, ""),
(
true,
r#"{"number":42,"title":"T","body":null,"state":"open","labels":[],"author":{"login":"octocat","id":"1"},"assignees":[],"createdAt":"2026-01-01T00:00:00Z","updatedAt":"2026-01-01T00:00:00Z","milestone":{"number":3,"title":"v2.0"},"url":"https://github.com/owner/repo/issues/42"}"#,
),
]);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let issue = provider
.edit(
42,
gitflow_core::issue::EditIssueArgs {
title: None,
body: None,
milestone: Some(Some("v2.0".to_string())),
},
)
.await
.expect("edit should succeed");
assert_eq!(issue.milestone.map(|m| m.title), Some("v2.0".to_string()));
let calls = runner.recorded_calls();
let edit_call = &calls[1].1;
assert!(
edit_call
.windows(2)
.any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
"issue edit argv must carry the resolved milestone title, got: {edit_call:?}"
);
}
#[tokio::test]
async fn test_should_send_remove_milestone_flag_without_resolving() {
let runner = MockCommandRunner::success("");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let _ = provider
.edit(
7,
gitflow_core::issue::EditIssueArgs {
title: None,
body: None,
milestone: Some(None),
},
)
.await;
let calls = runner.recorded_calls();
assert_eq!(calls.len(), 2, "no milestone resolution call expected");
assert!(
calls[0].1.iter().any(|a| a == "--remove-milestone"),
"edit argv must carry --remove-milestone, got: {:?}",
calls[0].1
);
}
#[tokio::test]
async fn test_should_wire_resolved_milestone_title_into_issue_list_filter() {
let runner =
SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON), (true, "[]")]);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let args = ListIssueArgs {
milestone: Some("v2.0".to_string()),
..ListIssueArgs::default()
};
provider.list(args).await.expect("list should succeed");
let calls = runner.recorded_calls();
let list_call = &calls[1].1;
assert!(
list_call
.windows(2)
.any(|w| w[0] == "--milestone" && w[1] == "v2.0"),
"issue list argv must carry the resolved milestone title, got: {list_call:?}"
);
}
}
#[cfg(test)]
mod contract_tests {
use super::*;
use crate::runner::MockCommandRunner;
#[tokio::test]
async fn test_contract_issue_list_github_v294_bot_author() {
let fixture = include_str!("../tests/fixtures/issue_list_github_v294_bot_author.json");
let runner = MockCommandRunner::success(fixture);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let issues = provider
.list(ListIssueArgs::default())
.await
.expect("gh v2.94 bot-author fixture must parse");
let issues = issues.items;
assert_eq!(issues.len(), 2);
assert_eq!(issues[0].number, 107);
assert_eq!(issues[0].author.login, "app/github-actions");
assert_eq!(issues[1].number, 42);
assert_eq!(issues[1].author.login, "test-user");
}
#[tokio::test]
async fn test_contract_issue_list_github_v2() {
let fixture = include_str!("../tests/fixtures/issue_list_github_v2.json");
let runner = MockCommandRunner::success(fixture);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let issues = provider
.list(ListIssueArgs::default())
.await
.expect("contract fixture must parse");
let issues = issues.items;
assert_eq!(issues.len(), 1);
let issue = &issues[0];
assert_eq!(issue.number, 42);
assert!(!issue.title.is_empty());
assert_eq!(issue.state, gitflow_core::types::State::Open);
assert_eq!(issue.author.login, "test-user");
}
#[tokio::test]
async fn test_contract_issue_list_github_v297_mixed_authors() {
let fixture = include_str!("../tests/fixtures/issue_list_github_v297_mixed_authors.json");
let runner = MockCommandRunner::success(fixture);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let issues = provider
.list(ListIssueArgs::default())
.await
.expect("gh v2.97 mixed-author fixture must parse");
let issues = issues.items;
assert_eq!(issues.len(), 2);
assert_eq!(issues[0].number, 108);
assert_eq!(issues[0].author.login, "app/github-actions");
assert_eq!(issues[0].author.id, "");
assert_eq!(issues[1].number, 117);
assert_eq!(issues[1].author.login, "byx-darwin");
assert!(!issues[1].author.id.is_empty());
}
#[tokio::test]
async fn test_contract_issue_view_github_v297_bot_author() {
let fixture = include_str!("../tests/fixtures/issue_view_github_v297_bot_author.json");
let runner = MockCommandRunner::success(fixture);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let issue = provider
.view(108)
.await
.expect("gh v2.97 bot-author view fixture must parse");
assert_eq!(issue.number, 108);
assert_eq!(issue.author.login, "app/github-actions");
assert_eq!(issue.author.id, "");
assert_eq!(issue.state, gitflow_core::types::State::Open);
}
#[tokio::test]
async fn test_should_request_default_cap_plus_one_when_limit_absent() {
let runner = MockCommandRunner::success("[]");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let paged = provider
.list(ListIssueArgs::default())
.await
.expect("list should succeed");
assert!(paged.items.is_empty());
assert!(!paged.truncated);
let args = &runner.recorded_calls()[0].1;
assert!(
args.windows(2).any(|w| w[0] == "--limit" && w[1] == "1001"),
"无 --limit 时必须向 gh 要 DEFAULT_LIST_LIMIT + 1 = 1001 条,实际 argv: {args:?}"
);
}
#[tokio::test]
async fn test_should_pass_user_limit_plus_one_to_gh() {
let runner = MockCommandRunner::success("[]");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let args = ListIssueArgs {
limit: Some(10),
..ListIssueArgs::default()
};
provider.list(args).await.expect("list should succeed");
let recorded = &runner.recorded_calls()[0].1;
assert!(
recorded
.windows(2)
.any(|w| w[0] == "--limit" && w[1] == "11"),
"用户指定 --limit 10 时也要跑 N+1 探测,实际 argv: {recorded:?}"
);
}
#[tokio::test]
async fn test_should_report_truncation_when_gh_returns_more_than_cap() {
let stdout = r#"[
{"number":1,"title":"a","state":"OPEN","body":"","labels":[],"assignees":[],"author":{"login":"u","id":"1"},"createdAt":"2026-01-01T00:00:00Z","updatedAt":"2026-01-01T00:00:00Z","url":"https://example.com/1"},
{"number":2,"title":"b","state":"OPEN","body":"","labels":[],"assignees":[],"author":{"login":"u","id":"1"},"createdAt":"2026-01-01T00:00:00Z","updatedAt":"2026-01-01T00:00:00Z","url":"https://example.com/2"},
{"number":3,"title":"c","state":"OPEN","body":"","labels":[],"assignees":[],"author":{"login":"u","id":"1"},"createdAt":"2026-01-01T00:00:00Z","updatedAt":"2026-01-01T00:00:00Z","url":"https://example.com/3"}
]"#;
let runner = MockCommandRunner::success(stdout);
let provider = GitHubIssueProvider::with_runner("owner/repo", runner);
let args = ListIssueArgs {
limit: Some(2),
..ListIssueArgs::default()
};
let paged = provider.list(args).await.expect("list should succeed");
assert_eq!(paged.items.len(), 2);
assert!(paged.truncated);
assert_eq!(paged.limit, 2);
}
#[tokio::test]
async fn test_should_forward_label_filter_to_gh() {
let runner = MockCommandRunner::success("[]");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let args = ListIssueArgs {
labels: vec!["bug".to_string(), "help wanted".to_string()],
..ListIssueArgs::default()
};
provider.list(args).await.expect("list should succeed");
let recorded = &runner.recorded_calls()[0].1;
assert!(
recorded
.windows(2)
.any(|w| w[0] == "--label" && w[1] == "bug"),
"--label 过滤此前被静默丢弃,必须真正传给 gh,实际 argv: {recorded:?}"
);
assert!(
recorded
.windows(2)
.any(|w| w[0] == "--label" && w[1] == "help wanted"),
"多个标签必须各自重复 --label,实际 argv: {recorded:?}"
);
}
#[tokio::test]
async fn test_should_list_issues_with_state_and_label_using_full_argv() {
let runner = MockCommandRunner::success("[]");
let provider = GitHubIssueProvider::with_runner("owner/repo", runner.clone());
let _ = provider
.list(ListIssueArgs {
state: Some(State::Open),
labels: vec!["bug".to_string()],
..ListIssueArgs::default()
})
.await;
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"issue",
"list",
"--repo",
"owner/repo",
"--json",
ISSUE_FIELDS,
"--state",
"open",
"--label",
"bug",
"--limit",
"1001"
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
}