use async_trait::async_trait;
use chrono::{DateTime, Utc};
use gitflow_core::{
CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, fetch_capped,
issue::{CreateIssueArgs, EditIssueArgs, IssueData, IssueProvider, ListIssueArgs},
types::{CommentData, Label, State, UserSummary},
};
use serde::Deserialize;
use tracing::debug;
use crate::{
GITLAB_MAX_PER_PAGE,
commit::encode_project_path,
error::parse_glab_error,
runner::{CommandRunner, RealCommandRunner},
};
#[derive(Debug, Clone)]
pub struct GitLabIssueProvider<R: CommandRunner = RealCommandRunner> {
repo: String,
repo_target: String,
runner: R,
}
impl GitLabIssueProvider<RealCommandRunner> {
#[must_use]
pub fn new(repo: impl Into<String>) -> Self {
let repo = repo.into();
Self {
repo_target: repo.clone(),
repo,
runner: RealCommandRunner,
}
}
#[must_use]
pub fn with_session(session: &gitflow_core::Session) -> Self {
let repo = session.repo.clone();
Self {
repo_target: repo.clone(),
repo,
runner: RealCommandRunner,
}
}
#[must_use]
pub fn with_remote_url(repo: impl Into<String>, remote_url: impl Into<String>) -> Self {
Self {
repo: repo.into(),
repo_target: remote_url.into(),
runner: RealCommandRunner,
}
}
}
impl<R: CommandRunner> GitLabIssueProvider<R> {
#[must_use]
pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
let repo = repo.into();
Self {
repo_target: repo.clone(),
repo,
runner,
}
}
#[must_use]
pub fn with_runner_and_repo_target(
repo: impl Into<String>,
repo_target: impl Into<String>,
runner: R,
) -> Self {
Self {
repo: repo.into(),
repo_target: repo_target.into(),
runner,
}
}
async fn ensure_label_exists(&self, name: &str) -> Result<()> {
debug!(repo = %self.repo, name, "auto-creating missing label via `glab label create`");
let output = self
.runner
.run(
"glab",
&[
"label",
"create",
"--name",
name,
"--color",
"ededed",
"--repo",
&self.repo_target,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab label create: {e}")))?;
if !output.status.success() {
let glab_err = parse_glab_error(&output.stderr);
tracing::debug!(error = %glab_err, "Failed to auto-create label");
return Err(CoreError::Platform(format!(
"Failed to auto-create label '{name}': {}",
glab_err.user_message
)));
}
Ok(())
}
}
#[derive(Debug, Clone, Deserialize)]
struct ApiUser {
username: String,
#[serde(default)]
id: u64,
}
impl From<&ApiUser> for UserSummary {
fn from(u: &ApiUser) -> Self {
Self {
login: u.username.clone(),
id: u.id.to_string(),
}
}
}
#[derive(Debug, Clone, Deserialize)]
struct MilestoneRefApi {
#[serde(default)]
id: u64,
#[serde(default)]
iid: Option<u64>,
title: String,
}
impl From<MilestoneRefApi> for gitflow_core::types::MilestoneRef {
fn from(api: MilestoneRefApi) -> Self {
Self {
number: api.iid.unwrap_or(api.id),
title: api.title,
}
}
}
#[derive(Debug, Clone, Deserialize)]
struct IssueApiResponse {
iid: u64,
title: String,
#[serde(default)]
description: Option<String>,
state: String,
#[serde(default)]
labels: Vec<String>,
#[serde(default)]
author: Option<ApiUser>,
#[serde(default)]
assignees: Vec<ApiUser>,
#[serde(default)]
created_at: Option<DateTime<Utc>>,
#[serde(default)]
updated_at: Option<DateTime<Utc>>,
#[serde(default)]
web_url: Option<String>,
#[serde(default)]
milestone: Option<MilestoneRefApi>,
}
impl From<IssueApiResponse> for IssueData {
fn from(api: IssueApiResponse) -> Self {
let labels: Vec<Label> = api
.labels
.into_iter()
.map(|name| Label {
name,
color: None,
description: None,
})
.collect();
let author = api.author.as_ref().map_or_else(
|| UserSummary {
login: "unknown".into(),
id: "0".to_string(),
},
UserSummary::from,
);
Self {
number: api.iid,
title: api.title,
body: api.description,
state: if api.state == "closed" {
State::Closed
} else {
State::Open
},
labels,
author,
assignees: api.assignees.iter().map(UserSummary::from).collect(),
created_at: api.created_at,
updated_at: api.updated_at,
url: api.web_url.unwrap_or_default(),
milestone: api.milestone.map(Into::into),
}
}
}
#[derive(Debug, Clone, Deserialize)]
struct CommentApiResponse {
id: u64,
#[serde(default)]
body: String,
#[serde(default)]
author: Option<ApiUser>,
#[serde(default)]
created_at: Option<DateTime<Utc>>,
}
impl From<CommentApiResponse> for CommentData {
fn from(api: CommentApiResponse) -> Self {
let author = api.author.as_ref().map_or_else(
|| UserSummary {
login: "unknown".into(),
id: "0".to_string(),
},
UserSummary::from,
);
Self {
id: api.id,
body: api.body,
author,
created_at: api.created_at,
}
}
}
impl<R: CommandRunner + Clone + 'static> GitLabIssueProvider<R> {
async fn list_impl(&self, args: ListIssueArgs) -> Result<Paged<IssueData>> {
let cap = args.limit.unwrap_or(DEFAULT_LIST_LIMIT);
let repo_target = &self.repo_target;
let repo = &self.repo;
let runner = &self.runner;
let state = args.state;
let search = &args.search;
let labels = &args.labels;
let milestone = &args.milestone;
let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
debug!(repo = %self.repo, cap, "spawning `glab issue list`");
fetch_capped(
FetchStrategy::Paged { per_page },
cap,
|page, per_page| async move {
let page_str = page.to_string();
let per_page_str = per_page.to_string();
let mut cmd_args: Vec<&str> =
vec!["issue", "list", "--repo", repo_target, "--output", "json"];
if let Some(state) = &state {
match state {
State::Closed => cmd_args.push("--closed"),
State::All => cmd_args.push("--all"),
State::Open => {}
}
}
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::GitLabMilestoneProvider::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("--per-page");
cmd_args.push(&per_page_str);
cmd_args.push("--page");
cmd_args.push(&page_str);
let output = runner
.run("glab", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let api_responses: Vec<IssueApiResponse> =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_responses.into_iter().map(IssueData::from).collect())
},
)
.await
}
}
#[async_trait]
impl<R: CommandRunner + Clone + 'static> IssueProvider for GitLabIssueProvider<R> {
async fn create(&self, args: CreateIssueArgs) -> Result<IssueData> {
let labels_joined = args.labels.join(",");
let assignees_joined = args.assignees.join(",");
let description = args.body.clone().unwrap_or_default();
let mut cmd_args: Vec<&str> = vec![
"issue",
"create",
"--repo",
&self.repo_target,
"--title",
&args.title,
"--description",
&description,
];
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::GitLabMilestoneProvider::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 `glab issue create`");
let output = self
.runner
.run("glab", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {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("glab", &cmd_args).await.map_err(|e| {
CoreError::Platform(format!("Failed to spawn glab on retry: {e}"))
})?;
if !retry_output.status.success() {
return Err(parse_glab_error(&retry_output.stderr).into());
}
let stdout = String::from_utf8_lossy(&retry_output.stdout);
let issue_iid = parse_issue_iid_from_url(&stdout).ok_or_else(|| {
CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
})?;
return self.view(issue_iid).await;
}
return Err(parse_glab_error(&output.stderr).into());
}
let stdout = String::from_utf8_lossy(&output.stdout);
let issue_iid = parse_issue_iid_from_url(&stdout).ok_or_else(|| {
CoreError::Platform(format!("Failed to parse issue URL from output: {stdout}"))
})?;
self.view(issue_iid).await
}
async fn edit(&self, number: u64, args: EditIssueArgs) -> Result<IssueData> {
debug!(repo = %self.repo, number, "spawning `glab issue update`");
let number_str = number.to_string();
let mut cmd_args: Vec<&str> =
vec!["issue", "update", &number_str, "--repo", &self.repo_target];
if let Some(title) = &args.title {
cmd_args.push("--title");
cmd_args.push(title);
}
if let Some(body) = &args.body {
cmd_args.push("--description");
cmd_args.push(body);
}
let resolved_milestone_title;
match &args.milestone {
None => {}
Some(None) => {
cmd_args.push("--milestone");
cmd_args.push("");
}
Some(Some(identifier)) => {
let milestone_provider = crate::GitLabMilestoneProvider::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("glab", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_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 `glab issue view`");
let number_str = number.to_string();
let output = self
.runner
.run(
"glab",
&[
"issue",
"view",
&number_str,
"--repo",
&self.repo_target,
"--output",
"json",
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let api_response: IssueApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_response.into())
}
async fn close(&self, number: u64) -> Result<IssueData> {
debug!(repo = %self.repo, number, "spawning `glab issue close`");
let number_str = number.to_string();
let output = self
.runner
.run(
"glab",
&["issue", "close", &number_str, "--repo", &self.repo_target],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
self.view(number).await
}
async fn reopen(&self, number: u64) -> Result<IssueData> {
debug!(repo = %self.repo, number, "spawning `glab issue reopen`");
let number_str = number.to_string();
let output = self
.runner
.run(
"glab",
&["issue", "reopen", &number_str, "--repo", &self.repo_target],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
self.view(number).await
}
async fn comment(&self, number: u64, body: &str) -> Result<CommentData> {
debug!(repo = %self.repo, number, "spawning `glab api` POST issue note");
let encoded_path = encode_project_path(&self.repo);
let api_path = format!("/projects/{encoded_path}/issues/{number}/notes");
let body_arg = format!("body={body}");
let output = self
.runner
.run(
"glab",
&["api", "--method", "POST", &api_path, "-f", &body_arg],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab api: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let api_response: CommentApiResponse =
serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
Ok(api_response.into())
}
async fn list_comments(&self, number: u64, limit: Option<u32>) -> Result<Paged<CommentData>> {
let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
let encoded_path = encode_project_path(&self.repo);
let encoded_path = &encoded_path;
let runner = &self.runner;
let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
debug!(repo = %self.repo, number, cap, "spawning `glab api` GET issue notes");
fetch_capped(
FetchStrategy::Paged { per_page },
cap,
|page, per_page| async move {
let api_path = format!(
"/projects/{encoded_path}/issues/{number}/notes?per_page={per_page}&\
page={page}"
);
let output = runner
.run("glab", &["api", &api_path])
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab api: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
let comments: Vec<CommentApiResponse> =
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 `glab issue update --label`"
);
let labels_joined = labels.join(",");
let number_str = number.to_string();
let cmd_args: Vec<&str> = vec![
"issue",
"update",
&number_str,
"--repo",
&self.repo_target,
"--label",
&labels_joined,
];
let output = self
.runner
.run("glab", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if output.status.success() {
return Ok(());
}
let missing = extract_missing_labels_from_error(&output.stderr);
if missing.is_empty() {
return Err(parse_glab_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("glab", &cmd_args)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab on retry: {e}")))?;
if !retry_output.status.success() {
return Err(parse_glab_error(&retry_output.stderr).into());
}
Ok(())
}
async fn remove_label(&self, number: u64, label: &str) -> Result<()> {
debug!(repo = %self.repo, number, label, "spawning `glab issue update --unlabel`");
let number_str = number.to_string();
let output = self
.runner
.run(
"glab",
&[
"issue",
"update",
&number_str,
"--repo",
&self.repo_target,
"--unlabel",
label,
],
)
.await
.map_err(|e| CoreError::Platform(format!("Failed to spawn glab: {e}")))?;
if !output.status.success() {
return Err(parse_glab_error(&output.stderr).into());
}
Ok(())
}
}
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
}
fn parse_issue_iid_from_url(url: &str) -> Option<u64> {
url.lines().find_map(|line| {
let line = line.trim();
for marker in ["/-/issues/", "/-/work_items/"] {
if line.contains(marker)
&& let Some(id) = line
.rsplit(marker)
.next()
.and_then(|s| s.split('/').next())
.and_then(|s| s.parse().ok())
{
return Some(id);
}
}
None
})
}
#[cfg(test)]
mod tests {
use super::*;
use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
#[test]
fn test_should_construct_gitlab_issue_provider() {
let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
assert_eq!(provider.repo, "gitlab-org/gitlab");
}
#[test]
fn test_should_construct_gitlab_issue_provider_from_string() {
let repo = String::from("gitlab-org/gitlab");
let provider = GitLabIssueProvider::new(repo);
assert_eq!(provider.repo, "gitlab-org/gitlab");
}
#[test]
fn test_should_deserialize_issue_api_response() {
let json = br#"{
"iid": 42,
"title": "Fix login bug",
"description": "Reproduced on v1.2.3",
"state": "opened",
"labels": ["bug", "critical"],
"author": {"username": "admin", "id": 1},
"assignees": [{"username": "alice", "id": 7}],
"created_at": "2026-01-15T09:30:00Z",
"updated_at": "2026-01-16T11:00:00Z",
"web_url": "https://gitlab.com/gitlab-org/gitlab/-/issues/42"
}"#;
let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
let issue: IssueData = api.into();
assert_eq!(issue.number, 42);
assert_eq!(issue.title, "Fix login bug");
assert_eq!(issue.body.as_deref(), Some("Reproduced on v1.2.3"));
assert_eq!(issue.state, State::Open);
assert_eq!(issue.labels.len(), 2);
assert_eq!(issue.labels[0].name, "bug");
assert_eq!(issue.author.login, "admin");
assert_eq!(issue.assignees.len(), 1);
assert_eq!(
issue.url,
"https://gitlab.com/gitlab-org/gitlab/-/issues/42"
);
}
#[test]
fn test_should_deserialize_closed_issue_api_response() {
let json = br#"{
"iid": 10,
"title": "Fixed typo",
"description": null,
"state": "closed",
"labels": [],
"author": {"username": "dev", "id": 5},
"assignees": [],
"created_at": "2026-06-01T08:00:00Z",
"updated_at": "2026-06-02T12:00:00Z",
"web_url": "https://gitlab.com/org/project/-/issues/10"
}"#;
let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
let issue: IssueData = api.into();
assert_eq!(issue.state, State::Closed);
}
#[test]
fn test_should_deserialize_comment_api_response() {
let json = br#"{
"id": 1001,
"body": "Thanks for reporting.",
"author": {"username": "maintainer", "id": 42},
"created_at": "2026-06-15T14:00:00Z"
}"#;
let api: CommentApiResponse =
serde_json::from_slice(json).expect("valid CommentApiResponse");
let comment: CommentData = api.into();
assert_eq!(comment.id, 1001);
assert_eq!(comment.body, "Thanks for reporting.");
assert_eq!(comment.author.login, "maintainer");
}
#[test]
fn test_should_handle_missing_author_with_fallback() {
let json = br#"{
"iid": 1,
"title": "No author",
"description": null,
"state": "opened",
"labels": [],
"author": null,
"assignees": [],
"created_at": null,
"updated_at": null,
"web_url": null
}"#;
let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
let issue: IssueData = api.into();
assert_eq!(issue.author.login, "unknown");
assert_eq!(issue.author.id, "0");
assert!(
issue.created_at.is_none(),
"missing created_at must stay None, not fall back to Utc::now()"
);
assert!(
issue.updated_at.is_none(),
"missing updated_at must stay None, not fall back to Utc::now()"
);
}
#[test]
fn test_should_keep_comment_created_at_none_when_api_omits_it() {
let json = br#"{
"id": 1002,
"body": "No timestamp provided.",
"author": {"username": "maintainer", "id": 42}
}"#;
let api: CommentApiResponse =
serde_json::from_slice(json).expect("valid CommentApiResponse");
let comment: CommentData = api.into();
assert!(
comment.created_at.is_none(),
"missing created_at must stay None, not fall back to Utc::now()"
);
}
#[test]
fn test_should_convert_labels_from_strings() {
let json = br#"{
"iid": 1,
"title": "Test",
"description": null,
"state": "opened",
"labels": ["bug", "enhancement", "documentation"],
"author": {"username": "admin", "id": 1},
"assignees": [],
"created_at": "2026-01-01T00:00:00Z",
"updated_at": "2026-01-01T00:00:00Z",
"web_url": "https://gitlab.com/x/y/-/issues/1"
}"#;
let api: IssueApiResponse = serde_json::from_slice(json).expect("valid IssueApiResponse");
let issue: IssueData = api.into();
assert_eq!(issue.labels.len(), 3);
assert_eq!(issue.labels[0].name, "bug");
assert_eq!(issue.labels[1].name, "enhancement");
assert!(issue.labels[0].color.is_none());
}
#[test]
fn test_should_deserialize_issue_with_milestone() {
let json = r#"{
"iid": 10,
"title": "gf-357 milestone test issue",
"description": "temp test issue for milestone shape investigation",
"state": "opened",
"labels": [],
"milestone": {
"id": 2,
"iid": 2,
"title": "gf-357-test-milestone",
"state": "active"
},
"web_url": "http://192.168.230.23/iproost/iproost-docs/-/work_items/10"
}"#;
let api: IssueApiResponse = serde_json::from_str(json).expect("deserialize");
let issue: IssueData = api.into();
assert_eq!(
issue.milestone,
Some(gitflow_core::types::MilestoneRef {
number: 2,
title: "gf-357-test-milestone".into(),
})
);
}
#[test]
fn test_should_deserialize_issue_with_no_milestone_field() {
let json = r#"{
"iid": 11,
"title": "No milestone",
"description": null,
"state": "opened",
"labels": [],
"web_url": "http://192.168.230.23/iproost/iproost-docs/-/issues/11"
}"#;
let api: IssueApiResponse = serde_json::from_str(json).expect("deserialize");
let issue: IssueData = api.into();
assert!(issue.milestone.is_none());
}
#[test]
fn test_should_deserialize_empty_issue_list() {
let json = b"[]";
let list: Vec<IssueApiResponse> = serde_json::from_slice(json).expect("valid empty list");
assert!(list.is_empty());
}
#[test]
fn test_should_debug_format_provider() {
let provider = GitLabIssueProvider::new("gitlab-org/gitlab");
let debug = format!("{provider:?}");
assert!(debug.contains("GitLabIssueProvider"));
assert!(debug.contains("gitlab-org/gitlab"));
}
#[test]
fn test_should_clone_gitlab_issue_provider() {
let original = GitLabIssueProvider::new("owner/repo");
let cloned = original.clone();
assert_eq!(original.repo, cloned.repo);
}
#[test]
fn test_should_parse_issue_iid_from_gitlab_url() {
assert_eq!(
parse_issue_iid_from_url("https://gitlab.com/owner/repo/-/issues/123"),
Some(123)
);
}
#[test]
fn test_should_parse_issue_iid_from_self_hosted_url() {
assert_eq!(
parse_issue_iid_from_url("https://gitlab.example.com/group/project/-/issues/456"),
Some(456)
);
}
#[test]
fn test_should_parse_issue_iid_from_multiline_output() {
let output = "Creating issue...\nhttps://gitlab.com/owner/repo/-/issues/789\nDone.";
assert_eq!(parse_issue_iid_from_url(output), Some(789));
}
#[test]
fn test_should_return_none_for_invalid_url() {
assert_eq!(parse_issue_iid_from_url("not a url"), None);
}
#[test]
fn test_should_return_none_for_url_without_iid() {
assert_eq!(
parse_issue_iid_from_url("https://gitlab.com/owner/repo/-/issues/"),
None
);
}
#[test]
fn test_should_parse_work_item_url() {
assert_eq!(
parse_issue_iid_from_url("http://192.168.230.23/iproost/iproost-docs/-/work_items/1"),
Some(1)
);
}
#[test]
fn test_should_parse_work_item_url_among_lines() {
let output =
"Creating issue...\nhttp://192.168.230.23/iproost/iproost-docs/-/work_items/7\nDone.";
assert_eq!(parse_issue_iid_from_url(output), Some(7));
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_view() {
let runner = MockCommandRunner::failure(r#"{"message": "Issue not found"}"#, 256);
let provider = GitLabIssueProvider::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 = GitLabIssueProvider::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_glab_fails_for_list() {
let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
let provider = GitLabIssueProvider::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 = GitLabIssueProvider::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(_)
));
}
#[tokio::test]
async fn test_should_list_all_issues_with_all_flag() {
let runner = MockCommandRunner::success("[]");
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
let _ = provider
.list(ListIssueArgs {
state: Some(State::All),
..Default::default()
})
.await;
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"issue",
"list",
"--repo",
"owner/repo",
"--output",
"json",
"--all",
"--per-page",
"100",
"--page",
"1"
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
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!["alice".to_string()],
milestone: None,
}
}
#[tokio::test]
async fn test_should_pass_empty_description_when_body_is_none() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, "https://gitlab.com/owner/repo/-/issues/7"),
(true, r#"{"iid":7,"title":"t","state":"opened"}"#),
]);
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
let args = CreateIssueArgs {
title: "t".to_string(),
body: None,
labels: vec![],
assignees: vec![],
milestone: None,
};
provider.create(args).await.expect("should create");
let calls = runner.recorded_calls();
let create_call = &calls[0];
let desc_idx = create_call
.1
.iter()
.position(|a| a == "--description")
.expect("--description flag must be present even when body is None");
assert_eq!(create_call.1[desc_idx + 1], "");
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_create() {
let runner = MockCommandRunner::failure(r#"{"message": "Validation failed"}"#, 256);
let provider = GitLabIssueProvider::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://gitlab.com/owner/repo/-/issues/7");
let provider = GitLabIssueProvider::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_glab_fails_for_close() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabIssueProvider::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 = GitLabIssueProvider::with_runner("owner/repo", runner);
let result = provider.close(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_glab_fails_for_reopen() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabIssueProvider::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 = GitLabIssueProvider::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_close_issue_without_output_json_flag_and_refetch_via_view() {
let runner = MockCommandRunner::success(
r#"{"iid":42,"title":"Fix","state":"closed","description":null,"labels":[]}"#,
);
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
let issue = provider.close(42).await.expect("close should succeed");
assert_eq!(issue.number, 42);
assert_eq!(issue.state, State::Closed);
let calls = runner.recorded_calls();
assert_eq!(
calls[0].1,
vec!["issue", "close", "42", "--repo", "owner/repo"]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
assert_eq!(calls[1].0, "glab");
assert!(calls[1].1.contains(&"--output".to_string()));
}
#[tokio::test]
async fn test_should_reopen_issue_without_output_json_flag_and_refetch_via_view() {
let runner = MockCommandRunner::success(
r#"{"iid":42,"title":"Fix","state":"opened","description":null,"labels":[]}"#,
);
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
let issue = provider.reopen(42).await.expect("reopen should succeed");
assert_eq!(issue.number, 42);
assert_eq!(issue.state, State::Open);
let calls = runner.recorded_calls();
assert_eq!(
calls[0].1,
vec!["issue", "reopen", "42", "--repo", "owner/repo"]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
assert!(calls[1].1.contains(&"--output".to_string()));
}
#[tokio::test]
async fn test_should_use_explicit_repo_target_for_view() {
let runner = MockCommandRunner::success(
r#"{"iid":42,"title":"Fix","state":"opened","description":null,"labels":[]}"#,
);
let provider = GitLabIssueProvider::with_runner_and_repo_target(
"owner/repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
runner.clone(),
);
let issue = provider.view(42).await.expect("view should succeed");
assert_eq!(issue.number, 42);
assert!(
runner.recorded_calls()[0]
.1
.contains(&"https://192.168.230.23/iproost/proxy/api-src.git".to_string())
);
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_comment() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabIssueProvider::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 = GitLabIssueProvider::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_post_issue_note_via_glab_api_with_message_field() {
let runner = MockCommandRunner::success(
r#"{"id":77,"body":"hello","author":{"username":"alice","id":1},"created_at":"2026-08-18T00:00:00Z"}"#,
);
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
let comment = provider.comment(42, "hello").await.expect("should post");
assert_eq!(comment.id, 77);
assert_eq!(comment.author.login, "alice");
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"api",
"--method",
"POST",
"/projects/owner%2Frepo/issues/42/notes",
"-f",
"body=hello",
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_encode_nested_group_repo_path_for_comment() {
let runner = MockCommandRunner::success(
r#"{"id":77,"body":"hello","author":{"username":"alice","id":1},"created_at":"2026-08-18T00:00:00Z"}"#,
);
let provider = GitLabIssueProvider::with_runner("group/subgroup/project", runner.clone());
let comment = provider.comment(42, "hello").await.expect("should post");
assert_eq!(comment.id, 77);
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"api",
"--method",
"POST",
"/projects/group%2Fsubgroup%2Fproject/issues/42/notes",
"-f",
"body=hello",
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_encode_nested_group_repo_path_for_list_comments() {
let runner = MockCommandRunner::success(
r#"[{"id":77,"body":"hello","author":{"username":"alice","id":1},"created_at":"2026-08-18T00:00:00Z"}]"#,
);
let provider = GitLabIssueProvider::with_runner("group/subgroup/project", runner.clone());
let paged = provider.list_comments(42, None).await.expect("should list");
assert_eq!(paged.items.len(), 1);
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"api",
"/projects/group%2Fsubgroup%2Fproject/issues/42/notes?per_page=100&page=1"
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_produce_complete_argv_for_list_comments_with_default_limit() {
let runner = MockCommandRunner::success("[]");
let provider = GitLabIssueProvider::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, "glab");
assert_eq!(
calls[0].1,
vec![
"api",
"/projects/owner%2Frepo/issues/359/notes?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 = GitLabIssueProvider::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_return_platform_error_when_glab_fails_for_add_labels() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabIssueProvider::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_return_platform_error_when_glab_fails_for_remove_label() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabIssueProvider::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(_)
));
}
#[tokio::test]
async fn test_should_call_issue_update_with_label_flag_for_add_labels() {
let runner = MockCommandRunner::success("");
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
let result = provider
.add_labels(42, &["bug".to_string(), "priority:high".to_string()])
.await;
assert!(result.is_ok(), "expected Ok, got {result:?}");
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"issue",
"update",
"42",
"--repo",
"owner/repo",
"--label",
"bug,priority:high"
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_use_explicit_repo_target_for_add_labels() {
let runner = MockCommandRunner::success("");
let provider = GitLabIssueProvider::with_runner_and_repo_target(
"owner/repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
runner.clone(),
);
let result = provider
.add_labels(42, &["priority:medium".to_string()])
.await;
assert!(result.is_ok(), "expected Ok, got {result:?}");
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"issue",
"update",
"42",
"--repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
"--label",
"priority:medium",
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_call_issue_update_with_unlabel_flag_for_remove_label() {
let runner = MockCommandRunner::success("");
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
let result = provider.remove_label(42, "bug").await;
assert!(result.is_ok(), "expected Ok, got {result:?}");
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"issue",
"update",
"42",
"--repo",
"owner/repo",
"--unlabel",
"bug"
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_use_explicit_repo_target_for_remove_label() {
let runner = MockCommandRunner::success("");
let provider = GitLabIssueProvider::with_runner_and_repo_target(
"owner/repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
runner.clone(),
);
let result = provider.remove_label(42, "priority:medium").await;
assert!(result.is_ok(), "expected Ok, got {result:?}");
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"issue",
"update",
"42",
"--repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
"--unlabel",
"priority:medium",
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_edit_issue_via_update_and_view_result() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, ""),
(
true,
r#"{"iid":42,"title":"New title","description":"orig","state":"opened","labels":[],"author":{"username":"admin","id":1},"assignees":[],"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-02T00:00:00Z","web_url":"https://gitlab.com/owner/repo/-/issues/42"}"#,
),
]);
let provider = GitLabIssueProvider::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_title_and_description_flags_for_edit() {
let runner = MockCommandRunner::success("");
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
let _ = provider
.edit(
7,
gitflow_core::issue::EditIssueArgs {
title: Some("T".to_string()),
body: Some("B".to_string()),
milestone: None,
},
)
.await;
assert_eq!(
runner.recorded_calls()[0].1,
vec![
"issue",
"update",
"7",
"--repo",
"owner/repo",
"--title",
"T",
"--description",
"B"
]
.into_iter()
.map(String::from)
.collect::<Vec<_>>()
);
}
#[tokio::test]
async fn test_should_return_platform_error_when_glab_fails_for_edit() {
let runner = MockCommandRunner::failure(r#"{"message": "Not found"}"#, 256);
let provider = GitLabIssueProvider::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(_)
));
}
#[test]
fn test_should_extract_single_missing_label_from_glab_stderr() {
let stderr = b"failed to update ...: 'type:enhancement' not found";
let missing = extract_missing_labels_from_error(stderr);
assert_eq!(missing, vec!["type:enhancement".to_string()]);
}
#[test]
fn test_should_return_empty_when_no_label_not_found_in_glab_stderr() {
let stderr = b"glab: Not logged in";
let missing = extract_missing_labels_from_error(stderr);
assert!(missing.is_empty());
}
#[tokio::test]
async fn test_should_auto_create_label_and_retry_on_add_labels_glab() {
let runner = SequencedMockCommandRunner::from_results(&[
(false, "failed to update ...: 'type:enhancement' not found"),
(true, "Created label type:enhancement"),
(true, ""),
]);
let provider = GitLabIssueProvider::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_propagate_error_when_glab_label_create_fails() {
let runner = SequencedMockCommandRunner::from_results(&[
(false, "failed to update ...: 'ghost' not found"),
(false, "glab: 403 Forbidden"),
]);
let provider = GitLabIssueProvider::with_runner("o/r", runner);
let result = provider.add_labels(1, &["ghost".to_string()]).await;
assert!(result.is_err());
}
#[tokio::test]
async fn test_should_not_retry_on_non_label_error_glab() {
let runner = SequencedMockCommandRunner::from_results(&[(false, "glab: Not logged in")]);
let provider = GitLabIssueProvider::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_walk_pages_with_per_page_100_on_glab() {
let runner = MockCommandRunner::success("[]");
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
provider
.list(ListIssueArgs::default())
.await
.expect("list should succeed");
let recorded = &runner.recorded_calls()[0].1;
assert!(
recorded
.windows(2)
.any(|w| w[0] == "--per-page" && w[1] == "100"),
"glab 的 --per-page 受 API 限制上限 100,必须按页大小而非总数传,实际 argv: \
{recorded:?}"
);
assert!(
recorded.windows(2).any(|w| w[0] == "--page" && w[1] == "1"),
"必须显式指定页号,实际 argv: {recorded:?}"
);
assert_eq!(
runner.recorded_calls().len(),
1,
"首页为空(短于 per_page)即已取尽,不得请求第 2 页"
);
}
#[tokio::test]
async fn test_should_forward_label_filter_to_glab() {
let runner = MockCommandRunner::success("[]");
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
let args = ListIssueArgs {
labels: vec!["bug".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 过滤此前被静默丢弃,必须真正传给 glab,实际 argv: {recorded:?}"
);
}
const MILESTONE_LIST_JSON: &str = r#"[
{"id": 30, "iid": 3, "title": "v2.0", "state": "active"}
]"#;
#[tokio::test]
async fn test_should_wire_resolved_milestone_title_into_issue_create() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, MILESTONE_LIST_JSON),
(true, "http://192.168.230.23/owner/repo/-/issues/42"),
(
true,
r#"{"iid":42,"title":"New feature","description":"Description","state":"opened","labels":[],"milestone":{"id":30,"iid":3,"title":"v2.0","state":"active"},"web_url":"http://192.168.230.23/owner/repo/-/issues/42"}"#,
),
]);
let provider = GitLabIssueProvider::with_runner("owner/repo", runner.clone());
let mut args = sample_create_args();
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 glab invocations");
assert!(
calls[0].1.first().map(String::as_str) == Some("milestone"),
"first call must resolve the milestone via `glab milestone list`, 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 = GitLabIssueProvider::with_runner("owner/repo", runner);
let mut args = sample_create_args();
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#"{"iid":42,"title":"T","description":null,"state":"opened","labels":[],"milestone":{"id":30,"iid":3,"title":"v2.0","state":"active"},"web_url":"http://192.168.230.23/owner/repo/-/issues/42"}"#,
),
]);
let provider = GitLabIssueProvider::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_empty_milestone_flag_to_unassign_without_resolving() {
let runner = MockCommandRunner::success("");
let provider = GitLabIssueProvider::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
.windows(2)
.any(|w| w[0] == "--milestone" && w[1].is_empty()),
"edit argv must carry --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 = GitLabIssueProvider::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:?}"
);
}
#[tokio::test]
async fn test_should_resolve_milestone_against_bare_repo_not_repo_target_for_create() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, MILESTONE_LIST_JSON),
(true, "http://192.168.230.23/owner/repo/-/issues/42"),
(
true,
r#"{"iid":42,"title":"T","description":null,"state":"opened","labels":[]}"#,
),
]);
let provider = GitLabIssueProvider::with_runner_and_repo_target(
"owner/repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
runner.clone(),
);
let mut args = sample_create_args();
args.milestone = Some("3".to_string());
provider.create(args).await.expect("create should succeed");
let resolve_call = &runner.recorded_calls()[0].1;
assert!(
resolve_call.iter().any(|a| a == "owner/repo"),
"milestone resolution must target the bare repo, got: {resolve_call:?}"
);
assert!(
!resolve_call
.iter()
.any(|a| a.contains("192.168.230.23/iproost/proxy")),
"milestone resolution must NOT use repo_target's remote URL, got: {resolve_call:?}"
);
}
#[tokio::test]
async fn test_should_resolve_milestone_against_bare_repo_not_repo_target_for_edit() {
let runner = SequencedMockCommandRunner::from_results(&[
(true, MILESTONE_LIST_JSON),
(true, ""),
(
true,
r#"{"iid":42,"title":"T","description":null,"state":"opened","labels":[]}"#,
),
]);
let provider = GitLabIssueProvider::with_runner_and_repo_target(
"owner/repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
runner.clone(),
);
provider
.edit(
42,
gitflow_core::issue::EditIssueArgs {
title: None,
body: None,
milestone: Some(Some("v2.0".to_string())),
},
)
.await
.expect("edit should succeed");
let resolve_call = &runner.recorded_calls()[0].1;
assert!(
resolve_call.iter().any(|a| a == "owner/repo"),
"milestone resolution must target the bare repo, got: {resolve_call:?}"
);
assert!(
!resolve_call
.iter()
.any(|a| a.contains("192.168.230.23/iproost/proxy")),
"milestone resolution must NOT use repo_target's remote URL, got: {resolve_call:?}"
);
}
#[tokio::test]
async fn test_should_resolve_milestone_against_bare_repo_not_repo_target_for_list() {
let runner =
SequencedMockCommandRunner::from_results(&[(true, MILESTONE_LIST_JSON), (true, "[]")]);
let provider = GitLabIssueProvider::with_runner_and_repo_target(
"owner/repo",
"https://192.168.230.23/iproost/proxy/api-src.git",
runner.clone(),
);
let args = ListIssueArgs {
milestone: Some("v2.0".to_string()),
..ListIssueArgs::default()
};
provider.list(args).await.expect("list should succeed");
let resolve_call = &runner.recorded_calls()[0].1;
assert!(
resolve_call.iter().any(|a| a == "owner/repo"),
"milestone resolution must target the bare repo, got: {resolve_call:?}"
);
assert!(
!resolve_call
.iter()
.any(|a| a.contains("192.168.230.23/iproost/proxy")),
"milestone resolution must NOT use repo_target's remote URL, got: {resolve_call:?}"
);
}
}
#[cfg(test)]
mod contract_tests {
use super::*;
use crate::runner::MockCommandRunner;
#[tokio::test]
async fn test_contract_issue_list_gitlab_v1() {
let fixture = include_str!("../tests/fixtures/issue_list_gitlab_v1.json");
let runner = MockCommandRunner::success(fixture);
let provider = GitLabIssueProvider::with_runner("group/project", 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, 10);
assert!(!issue.title.is_empty());
assert_eq!(issue.state, gitflow_core::types::State::Open);
}
}