Skip to main content

gitflow_gitcode/
label.rs

1//! GitCode Label 和 Milestone 提供者实现。
2//!
3//! 通过 `gc label` 和 `gc api` CLI 命令实现 [`LabelProvider`] 和
4//! [`MilestoneProvider`] trait,支持标签和里程碑的完整生命周期管理。
5
6use async_trait::async_trait;
7use chrono::{DateTime, Utc};
8use gitflow_core::{
9    CoreError, DEFAULT_LIST_LIMIT, FetchStrategy, Paged, Result, Session, fetch_capped,
10    label::{
11        CreateLabelArgs, CreateMilestoneArgs, LabelData, LabelProvider, MilestoneData,
12        MilestoneProvider,
13    },
14    types::State,
15};
16use serde::Deserialize;
17use tracing::debug;
18
19use crate::{
20    error::parse_gitcode_error,
21    runner::{CommandRunner, RealCommandRunner},
22};
23
24/// GitCode Label 提供者,通过 `gitcode` CLI 管理仓库标签。
25///
26/// # Examples
27///
28/// ```no_run
29/// use gitflow_gitcode::GitCodeLabelProvider;
30///
31/// let provider = GitCodeLabelProvider::new("octocat/hello-world");
32/// ```
33#[derive(Debug, Clone)]
34pub struct GitCodeLabelProvider<R: CommandRunner = RealCommandRunner> {
35    /// GitCode `owner/repo`。
36    repo: String,
37    /// 用于执行 `gitcode` CLI 命令的 runner。
38    runner: R,
39}
40
41impl GitCodeLabelProvider<RealCommandRunner> {
42    /// 创建新的 GitCode Label 提供者。
43    ///
44    /// `repo` 格式为 `owner/repo`。
45    #[must_use]
46    pub fn new(repo: impl Into<String>) -> Self {
47        Self {
48            repo: repo.into(),
49            runner: RealCommandRunner,
50        }
51    }
52
53    /// Create a new provider from a shared [`Session`].
54    ///
55    /// This enables state reuse across multiple operations in workflow chains.
56    #[must_use]
57    pub fn with_session(session: &Session) -> Self {
58        Self {
59            repo: session.repo.clone(),
60            runner: RealCommandRunner,
61        }
62    }
63}
64
65impl<R: CommandRunner> GitCodeLabelProvider<R> {
66    /// 使用自定义 [`CommandRunner`] 创建提供者。
67    ///
68    /// 主要用于测试,可注入模拟 runner 以控制 `gitcode` CLI 的输出。
69    /// `repo` 格式为 `owner/repo`。
70    #[must_use]
71    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
72        Self {
73            repo: repo.into(),
74            runner,
75        }
76    }
77}
78
79/// `gc label list/create` 请求的 JSON 字段列表。
80const LABEL_FIELDS: &str = "name,color,description";
81
82#[async_trait]
83impl<R: CommandRunner + 'static> LabelProvider for GitCodeLabelProvider<R> {
84    async fn create(&self, args: CreateLabelArgs) -> Result<LabelData> {
85        debug!(
86            repo = %self.repo,
87            name = %args.name,
88            color = %args.color,
89            "spawning `gc label create`"
90        );
91
92        let mut cmd = tokio::process::Command::new(crate::gitcode_binary());
93        cmd.args(["label", "create"])
94            .arg(&args.name)
95            .arg("--color")
96            .arg(&args.color)
97            .arg("-R")
98            .arg(&self.repo)
99            .arg("--json");
100
101        if let Some(ref desc) = args.description {
102            cmd.arg("--description").arg(desc);
103        }
104
105        let output = cmd.output().await.map_err(|e| {
106            CoreError::Platform(format!("Failed to spawn gitcode label create: {e}"))
107        })?;
108
109        if !output.status.success() {
110            return Err(parse_gitcode_error(&output.stderr).into());
111        }
112
113        let label: LabelData =
114            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
115
116        Ok(label)
117    }
118
119    async fn list(&self, limit: Option<u32>) -> Result<Paged<LabelData>> {
120        let binary = crate::gitcode_binary();
121        let binary = &binary;
122        let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
123        let repo = &self.repo;
124        let runner = &self.runner;
125
126        // 实测(gitcode-cli 0.12.0):`label list` 支持 `--page`(默认 1)与
127        // `--per-page`,`--per-page 2 --page 1/2` 返回不重叠 —— 分页真实生效。
128        let per_page = cap.saturating_add(1).min(crate::GITCODE_API_MAX_PER_PAGE);
129
130        debug!(repo = %self.repo, cap, per_page, "spawning `gitcode label list`");
131
132        fetch_capped(
133            FetchStrategy::Paged { per_page },
134            cap,
135            |page, per_page| async move {
136                let page_str = page.to_string();
137                let per_page_str = per_page.to_string();
138                let output = runner
139                    .run(
140                        binary,
141                        &[
142                            "label",
143                            "list",
144                            "-R",
145                            repo,
146                            "--json",
147                            "--per-page",
148                            &per_page_str,
149                            "--page",
150                            &page_str,
151                        ],
152                    )
153                    .await
154                    .map_err(|e| {
155                        CoreError::Platform(format!("Failed to spawn gitcode label list: {e}"))
156                    })?;
157
158                if !output.status.success() {
159                    return Err(parse_gitcode_error(&output.stderr).into());
160                }
161
162                let labels: Vec<LabelData> =
163                    serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
164
165                Ok(labels)
166            },
167        )
168        .await
169    }
170
171    async fn edit(&self, name: &str, args: CreateLabelArgs) -> Result<LabelData> {
172        debug!(repo = %self.repo, name, "spawning `gc label edit`");
173
174        let mut cmd = tokio::process::Command::new(crate::gitcode_binary());
175        cmd.args(["label", "edit"])
176            .arg(name)
177            .arg("-R")
178            .arg(&self.repo)
179            .arg("--color")
180            .arg(&args.color)
181            .arg("--json");
182
183        if let Some(ref desc) = args.description {
184            cmd.arg("--description").arg(desc);
185        }
186
187        let output = cmd
188            .output()
189            .await
190            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode label edit: {e}")))?;
191
192        if !output.status.success() {
193            return Err(parse_gitcode_error(&output.stderr).into());
194        }
195
196        // Try to parse JSON response, fallback to fetch if not available
197        if let Ok(label) = serde_json::from_slice::<LabelData>(&output.stdout) {
198            Ok(label)
199        } else {
200            self.fetch_label(name).await
201        }
202    }
203
204    async fn delete(&self, name: &str) -> Result<()> {
205        debug!(repo = %self.repo, name, "spawning `gc label delete`");
206
207        let output = tokio::process::Command::new(crate::gitcode_binary())
208            .args(["label", "delete"])
209            .arg(name)
210            .arg("--yes")
211            .arg("-R")
212            .arg(&self.repo)
213            .output()
214            .await
215            .map_err(|e| {
216                CoreError::Platform(format!("Failed to spawn gitcode label delete: {e}"))
217            })?;
218
219        if !output.status.success() {
220            return Err(parse_gitcode_error(&output.stderr).into());
221        }
222
223        Ok(())
224    }
225}
226
227impl<R: CommandRunner> GitCodeLabelProvider<R> {
228    /// 获取指定名称的标签数据(内部辅助方法)。
229    async fn fetch_label(&self, name: &str) -> Result<LabelData> {
230        let output = tokio::process::Command::new(crate::gitcode_binary())
231            .args(["label", "view"])
232            .arg(name)
233            .arg("--repo")
234            .arg(&self.repo)
235            .arg("--json")
236            .arg(LABEL_FIELDS)
237            .output()
238            .await
239            .map_err(|e| CoreError::Platform(format!("Failed to spawn gitcode label view: {e}")))?;
240
241        if !output.status.success() {
242            return Err(parse_gitcode_error(&output.stderr).into());
243        }
244
245        let label: LabelData =
246            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
247
248        Ok(label)
249    }
250}
251
252/// GitCode 里程碑提供者,通过 `gc api` 管理仓库里程碑。
253///
254/// # Examples
255///
256/// ```no_run
257/// use gitflow_gitcode::GitCodeMilestoneProvider;
258///
259/// let provider = GitCodeMilestoneProvider::new("octocat/hello-world");
260/// ```
261#[derive(Debug, Clone)]
262pub struct GitCodeMilestoneProvider<R: CommandRunner = RealCommandRunner> {
263    /// GitCode `owner/repo`。
264    repo: String,
265    /// 用于执行 `gitcode` CLI 命令的 runner。
266    runner: R,
267}
268
269impl GitCodeMilestoneProvider<RealCommandRunner> {
270    /// 创建新的 GitCode Milestone 提供者。
271    ///
272    /// `repo` 格式为 `owner/repo`。
273    #[must_use]
274    pub fn new(repo: impl Into<String>) -> Self {
275        Self {
276            repo: repo.into(),
277            runner: RealCommandRunner,
278        }
279    }
280
281    /// Create a new provider from a shared [`Session`].
282    ///
283    /// This enables state reuse across multiple operations in workflow chains.
284    #[must_use]
285    pub fn with_session(session: &Session) -> Self {
286        Self {
287            repo: session.repo.clone(),
288            runner: RealCommandRunner,
289        }
290    }
291}
292
293impl<R: CommandRunner> GitCodeMilestoneProvider<R> {
294    /// 使用自定义 [`CommandRunner`] 创建提供者。
295    ///
296    /// 主要用于测试,可注入模拟 runner 以控制 `gitcode` CLI 的输出。
297    /// `repo` 格式为 `owner/repo`。
298    #[must_use]
299    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
300        Self {
301            repo: repo.into(),
302            runner,
303        }
304    }
305}
306
307/// `gc api milestones` 返回的 JSON 结构。
308#[derive(Debug, Clone, Deserialize)]
309struct MilestoneApiResponse {
310    number: u64,
311    title: String,
312    #[serde(default)]
313    description: Option<String>,
314    state: String,
315    #[serde(default)]
316    due_on: Option<String>,
317    #[serde(default)]
318    closed_issues: u64,
319    #[serde(default)]
320    open_issues: u64,
321}
322
323impl From<MilestoneApiResponse> for MilestoneData {
324    fn from(api: MilestoneApiResponse) -> Self {
325        Self {
326            number: api.number,
327            title: api.title,
328            description: api.description,
329            state: if api.state == "closed" {
330                State::Closed
331            } else {
332                State::Open
333            },
334            due_on: api.due_on.and_then(|s| {
335                // GitCode returns due_on as either full RFC3339 or a pure
336                // "YYYY-MM-DD" date (issue #377); fall back to the latter,
337                // anchored at midnight UTC, before giving up.
338                if let Ok(dt) = DateTime::parse_from_rfc3339(&s) {
339                    return Some(dt.with_timezone(&Utc));
340                }
341                chrono::NaiveDate::parse_from_str(&s, "%Y-%m-%d")
342                    .ok()
343                    .and_then(|d| d.and_hms_opt(0, 0, 0))
344                    .map(|naive_dt| DateTime::<Utc>::from_naive_utc_and_offset(naive_dt, Utc))
345            }),
346            closed_issues: api.closed_issues,
347            open_issues: api.open_issues,
348        }
349    }
350}
351
352#[async_trait]
353impl<R: CommandRunner + 'static> MilestoneProvider for GitCodeMilestoneProvider<R> {
354    async fn create(&self, args: CreateMilestoneArgs) -> Result<MilestoneData> {
355        debug!(repo = %self.repo, title = %args.title, "spawning `gc milestone create`");
356
357        let mut cmd = tokio::process::Command::new(crate::gitcode_binary());
358        cmd.args(["milestone", "create"])
359            .arg(&args.title)
360            .arg("-R")
361            .arg(&self.repo)
362            .arg("--json");
363
364        if let Some(ref desc) = args.description {
365            cmd.arg("--description").arg(desc);
366        }
367
368        if let Some(ref due) = args.due_on {
369            cmd.arg("--due-date")
370                .arg(due.format("%Y-%m-%d").to_string());
371        }
372
373        let output = cmd.output().await.map_err(|e| {
374            CoreError::Platform(format!("Failed to spawn gitcode milestone create: {e}"))
375        })?;
376
377        if !output.status.success() {
378            return Err(parse_gitcode_error(&output.stderr).into());
379        }
380
381        let api_response: MilestoneApiResponse =
382            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
383
384        Ok(api_response.into())
385    }
386
387    async fn list(&self, limit: Option<u32>) -> Result<Paged<MilestoneData>> {
388        let binary = crate::gitcode_binary();
389        let binary = &binary;
390        let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
391        let repo = &self.repo;
392        let runner = &self.runner;
393
394        // 见 label list 同处注释:`--page` / `--per-page` 已实测可用。
395        let per_page = cap.saturating_add(1).min(crate::GITCODE_API_MAX_PER_PAGE);
396
397        debug!(repo = %self.repo, cap, per_page, "spawning `gitcode milestone list`");
398
399        fetch_capped(
400            FetchStrategy::Paged { per_page },
401            cap,
402            |page, per_page| async move {
403                let page_str = page.to_string();
404                let per_page_str = per_page.to_string();
405                let output = runner
406                    .run(
407                        binary,
408                        &[
409                            "milestone",
410                            "list",
411                            "-R",
412                            repo,
413                            "--json",
414                            "--per-page",
415                            &per_page_str,
416                            "--page",
417                            &page_str,
418                        ],
419                    )
420                    .await
421                    .map_err(|e| {
422                        CoreError::Platform(format!("Failed to spawn gitcode milestone list: {e}"))
423                    })?;
424
425                if !output.status.success() {
426                    return Err(parse_gitcode_error(&output.stderr).into());
427                }
428
429                let milestones: Vec<MilestoneApiResponse> =
430                    serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
431
432                Ok(milestones.into_iter().map(MilestoneData::from).collect())
433            },
434        )
435        .await
436    }
437
438    async fn edit(&self, number: u64, args: CreateMilestoneArgs) -> Result<MilestoneData> {
439        debug!(repo = %self.repo, number, "spawning `gc milestone edit`");
440
441        let mut cmd = tokio::process::Command::new(crate::gitcode_binary());
442        cmd.args(["milestone", "edit"])
443            .arg(number.to_string())
444            .arg("-R")
445            .arg(&self.repo)
446            .arg("--title")
447            .arg(&args.title)
448            .arg("--json");
449
450        if let Some(ref desc) = args.description {
451            cmd.arg("--description").arg(desc);
452        }
453
454        if let Some(ref due) = args.due_on {
455            cmd.arg("--due-date")
456                .arg(due.format("%Y-%m-%d").to_string());
457        }
458
459        let output = cmd.output().await.map_err(|e| {
460            CoreError::Platform(format!("Failed to spawn gitcode milestone edit: {e}"))
461        })?;
462
463        if !output.status.success() {
464            return Err(parse_gitcode_error(&output.stderr).into());
465        }
466
467        let api_response: MilestoneApiResponse =
468            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
469
470        Ok(api_response.into())
471    }
472
473    async fn close(&self, number: u64) -> Result<MilestoneData> {
474        debug!(repo = %self.repo, number, "spawning `gc milestone close`");
475
476        let output = tokio::process::Command::new(crate::gitcode_binary())
477            .args(["milestone", "close"])
478            .arg(number.to_string())
479            .arg("-R")
480            .arg(&self.repo)
481            .arg("--json")
482            .output()
483            .await
484            .map_err(|e| {
485                CoreError::Platform(format!("Failed to spawn gitcode milestone close: {e}"))
486            })?;
487
488        if !output.status.success() {
489            return Err(parse_gitcode_error(&output.stderr).into());
490        }
491
492        let api_response: MilestoneApiResponse =
493            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
494
495        Ok(api_response.into())
496    }
497
498    async fn reopen(&self, number: u64) -> Result<MilestoneData> {
499        debug!(repo = %self.repo, number, "spawning `gc milestone reopen`");
500
501        let output = tokio::process::Command::new(crate::gitcode_binary())
502            .args(["milestone", "reopen"])
503            .arg(number.to_string())
504            .arg("-R")
505            .arg(&self.repo)
506            .arg("--json")
507            .output()
508            .await
509            .map_err(|e| {
510                CoreError::Platform(format!("Failed to spawn gitcode milestone reopen: {e}"))
511            })?;
512
513        if !output.status.success() {
514            return Err(parse_gitcode_error(&output.stderr).into());
515        }
516
517        let api_response: MilestoneApiResponse =
518            serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)?;
519
520        Ok(api_response.into())
521    }
522}
523
524#[cfg(test)]
525mod tests {
526    use super::*;
527
528    // --- GitCodeLabelProvider tests ---
529
530    #[test]
531    fn test_should_construct_gitcode_label_provider() {
532        let provider = GitCodeLabelProvider::new("octocat/hello-world");
533        assert_eq!(provider.repo, "octocat/hello-world");
534    }
535
536    #[test]
537    fn test_should_construct_gitcode_label_provider_from_string() {
538        let repo = String::from("octocat/hello-world");
539        let provider = GitCodeLabelProvider::new(repo);
540        assert_eq!(provider.repo, "octocat/hello-world");
541    }
542
543    #[test]
544    fn test_should_debug_format_label_provider() {
545        let provider = GitCodeLabelProvider::new("owner/repo");
546        let debug = format!("{provider:?}");
547        assert!(debug.contains("GitCodeLabelProvider"));
548        assert!(debug.contains("owner/repo"));
549    }
550
551    #[test]
552    fn test_should_clone_gitcode_label_provider() {
553        let original = GitCodeLabelProvider::new("owner/repo");
554        let cloned = original.clone();
555        assert_eq!(original.repo, cloned.repo);
556    }
557
558    // --- GitCodeMilestoneProvider tests ---
559
560    #[test]
561    fn test_should_construct_gitcode_milestone_provider() {
562        let provider = GitCodeMilestoneProvider::new("octocat/hello-world");
563        assert_eq!(provider.repo, "octocat/hello-world");
564    }
565
566    #[test]
567    fn test_should_debug_format_milestone_provider() {
568        let provider = GitCodeMilestoneProvider::new("owner/repo");
569        let debug = format!("{provider:?}");
570        assert!(debug.contains("GitCodeMilestoneProvider"));
571        assert!(debug.contains("owner/repo"));
572    }
573
574    #[test]
575    fn test_should_clone_gitcode_milestone_provider() {
576        let original = GitCodeMilestoneProvider::new("owner/repo");
577        let cloned = original.clone();
578        assert_eq!(original.repo, cloned.repo);
579    }
580
581    // --- LabelData deserialization tests ---
582
583    #[test]
584    fn test_should_deserialize_label_data_from_gc_output() {
585        let json = br#"[
586            {"name": "bug", "color": "d73a4a", "description": "Something isn't working"},
587            {"name": "enhancement", "color": "a2eeef", "description": null}
588        ]"#;
589
590        let labels: Vec<LabelData> = serde_json::from_slice(json).expect("valid LabelData list");
591        assert_eq!(labels.len(), 2);
592        assert_eq!(labels[0].name, "bug");
593        assert_eq!(labels[0].color.as_deref(), Some("d73a4a"));
594        assert_eq!(labels[1].description, None);
595    }
596
597    #[test]
598    fn test_should_deserialize_single_label_from_gc_output() {
599        let json = br#"{"name": "wip", "color": "ffff00", "description": "Work in progress"}"#;
600
601        let label: LabelData = serde_json::from_slice(json).expect("valid LabelData");
602        assert_eq!(label.name, "wip");
603        assert_eq!(label.color.as_deref(), Some("ffff00"));
604        assert_eq!(label.description.as_deref(), Some("Work in progress"));
605    }
606
607    #[test]
608    fn test_should_deserialize_empty_label_list() {
609        let json = b"[]";
610        let labels: Vec<LabelData> =
611            serde_json::from_slice(json).expect("valid empty LabelData list");
612        assert!(labels.is_empty());
613    }
614
615    // --- MilestoneData deserialization tests ---
616
617    #[test]
618    fn test_should_deserialize_milestone_api_response() {
619        let json = br#"{
620            "number": 1,
621            "title": "v1.0 Release",
622            "description": "First stable release",
623            "state": "open",
624            "due_on": "2026-06-01T00:00:00Z",
625            "closed_issues": 10,
626            "open_issues": 5
627        }"#;
628
629        let api: MilestoneApiResponse =
630            serde_json::from_slice(json).expect("valid MilestoneApiResponse");
631        let data: MilestoneData = api.into();
632
633        assert_eq!(data.number, 1);
634        assert_eq!(data.title, "v1.0 Release");
635        assert_eq!(data.description, Some("First stable release".into()));
636        assert_eq!(data.state, State::Open);
637        assert!(data.due_on.is_some());
638        assert_eq!(data.closed_issues, 10);
639        assert_eq!(data.open_issues, 5);
640    }
641
642    #[test]
643    fn test_should_deserialize_closed_milestone() {
644        let json = br#"{
645            "number": 2,
646            "title": "v0.9 Beta",
647            "description": null,
648            "state": "closed",
649            "due_on": null,
650            "closed_issues": 20,
651            "open_issues": 0
652        }"#;
653
654        let api: MilestoneApiResponse =
655            serde_json::from_slice(json).expect("valid MilestoneApiResponse");
656        let data: MilestoneData = api.into();
657
658        assert_eq!(data.state, State::Closed);
659        assert!(data.description.is_none());
660        assert!(data.due_on.is_none());
661    }
662
663    #[test]
664    fn test_should_deserialize_milestone_list() {
665        let json = br#"[
666            {"number": 1, "title": "v1.0", "description": null, "state": "open", "due_on": null, "closed_issues": 0, "open_issues": 3},
667            {"number": 2, "title": "v0.9", "description": "Beta", "state": "closed", "due_on": "2026-01-01T00:00:00Z", "closed_issues": 15, "open_issues": 0}
668        ]"#;
669
670        let milestones: Vec<MilestoneApiResponse> =
671            serde_json::from_slice(json).expect("valid MilestoneApiResponse list");
672        assert_eq!(milestones.len(), 2);
673        assert_eq!(milestones[0].title, "v1.0");
674        assert_eq!(milestones[1].title, "v0.9");
675    }
676
677    #[test]
678    fn test_should_default_issue_counts_when_absent_from_real_list_response() {
679        // 真实响应形状(2026-09-19 对 gitcode milestone list --repo openharmony/docs
680        // 的实测):closed_issues/open_issues 键完全不存在,不是"值为 0"。
681        //
682        // 该真实响应的 due_on 是纯日期格式("2026-08-31",无时间/时区部分)。见
683        // Issue #377。
684        let json = br#"{
685            "id": null,
686            "number": 733070,
687            "title": "IT26_OpenHarmony 7.0(Release)",
688            "description": "",
689            "state": "active",
690            "due_on": "2026-08-31"
691        }"#;
692
693        let api: MilestoneApiResponse =
694            serde_json::from_slice(json).expect("valid MilestoneApiResponse");
695        let data: MilestoneData = api.into();
696
697        assert_eq!(data.number, 733_070);
698        assert_eq!(
699            data.closed_issues, 0,
700            "键缺失时应靠 #[serde(default)] 落到 0,而不是反序列化失败"
701        );
702        assert_eq!(
703            data.due_on,
704            Some(
705                chrono::DateTime::parse_from_rfc3339("2026-08-31T00:00:00Z")
706                    .expect("valid rfc3339")
707                    .with_timezone(&Utc)
708            ),
709            "纯日期格式的 due_on 应解析为当天 UTC 零点,而不是静默丢弃为 None(#377)"
710        );
711        assert_eq!(data.open_issues, 0);
712    }
713
714    #[test]
715    fn test_should_convert_milestone_api_to_data() {
716        let api = MilestoneApiResponse {
717            number: 42,
718            title: "Test Milestone".into(),
719            description: Some("A test".into()),
720            state: "open".into(),
721            due_on: Some("2026-12-01T00:00:00Z".into()),
722            closed_issues: 5,
723            open_issues: 10,
724        };
725
726        let data: MilestoneData = api.clone().into();
727        assert_eq!(data.number, api.number);
728        assert_eq!(data.title, api.title);
729    }
730
731    // --- Runner-routing regression tests ---
732    //
733    // `list` 曾直接 `tokio::process::Command::new(...)`,绕过可注入的
734    // `CommandRunner`,导致其 argv 无法被测试观测。以下测试确认两者
735    // 均已改为通过 `self.runner` 派发。
736
737    use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
738
739    #[tokio::test]
740    #[allow(
741        clippy::similar_names,
742        reason = "page1/page2 fixtures vs paged result read clearly in test context"
743    )]
744    async fn test_should_page_through_gitcode_label_list_with_incrementing_page_numbers() {
745        // cap=100 → per_page=100,want=101;首页满 100 条 ⇒ 必然发出第二页。
746        fn label_page_json(start: u32, count: u32) -> String {
747            let items: Vec<String> = (start..start + count)
748                .map(|n| format!(r##"{{"name":"l{n}","color":"#ffffff","description":""}}"##))
749                .collect();
750            format!("[{}]", items.join(","))
751        }
752        let page1 = label_page_json(1, 100);
753        let page2 = label_page_json(101, 100);
754        let runner = SequencedMockCommandRunner::from_results(&[(true, &page1), (true, &page2)]);
755        let provider = GitCodeLabelProvider::with_runner("owner/repo", runner.clone());
756
757        let paged = provider.list(Some(100)).await.expect("should list");
758
759        assert_eq!(paged.items.len(), 100);
760        assert!(paged.truncated);
761
762        let calls = runner.recorded_calls();
763        assert_eq!(
764            calls.len(),
765            2,
766            "必须真的翻到第二页,实际调用数: {}",
767            calls.len()
768        );
769        assert!(
770            calls[0]
771                .1
772                .windows(2)
773                .any(|w| w[0] == "--per-page" && w[1] == "100"),
774            "实际 argv: {:?}",
775            calls[0].1
776        );
777        assert!(
778            calls[0]
779                .1
780                .windows(2)
781                .any(|w| w[0] == "--page" && w[1] == "1"),
782            "实际 argv: {:?}",
783            calls[0].1
784        );
785        assert!(
786            calls[1]
787                .1
788                .windows(2)
789                .any(|w| w[0] == "--page" && w[1] == "2"),
790            "页号必须递增,实际 argv: {:?}",
791            calls[1].1
792        );
793    }
794
795    #[tokio::test]
796    #[allow(
797        clippy::similar_names,
798        reason = "page1/page2 fixtures vs paged result read clearly in test context"
799    )]
800    async fn test_should_page_through_gitcode_milestone_list_with_incrementing_page_numbers() {
801        // cap=100 → per_page=100,want=101;首页满 100 条 ⇒ 必然发出第二页。
802        fn milestone_page_json(start: u64, count: u64) -> String {
803            let items: Vec<String> = (start..start + count)
804                .map(|n| {
805                    format!(
806                        r#"{{"number":{n},"title":"m{n}","description":null,"state":"open","due_on":null,"closed_issues":0,"open_issues":0}}"#
807                    )
808                })
809                .collect();
810            format!("[{}]", items.join(","))
811        }
812        let page1 = milestone_page_json(1, 100);
813        let page2 = milestone_page_json(101, 100);
814        let runner = SequencedMockCommandRunner::from_results(&[(true, &page1), (true, &page2)]);
815        let provider = GitCodeMilestoneProvider::with_runner("owner/repo", runner.clone());
816
817        let paged = provider.list(Some(100)).await.expect("should list");
818
819        assert_eq!(paged.items.len(), 100);
820        assert!(paged.truncated);
821
822        let calls = runner.recorded_calls();
823        assert_eq!(
824            calls.len(),
825            2,
826            "必须真的翻到第二页,实际调用数: {}",
827            calls.len()
828        );
829        assert!(
830            calls[0]
831                .1
832                .windows(2)
833                .any(|w| w[0] == "--per-page" && w[1] == "100"),
834            "实际 argv: {:?}",
835            calls[0].1
836        );
837        assert!(
838            calls[0]
839                .1
840                .windows(2)
841                .any(|w| w[0] == "--page" && w[1] == "1"),
842            "实际 argv: {:?}",
843            calls[0].1
844        );
845        assert!(
846            calls[1]
847                .1
848                .windows(2)
849                .any(|w| w[0] == "--page" && w[1] == "2"),
850            "页号必须递增,实际 argv: {:?}",
851            calls[1].1
852        );
853    }
854
855    #[tokio::test]
856    async fn test_should_route_label_list_through_runner() {
857        let runner = MockCommandRunner::success("[]");
858        let provider = GitCodeLabelProvider::with_runner("owner/repo", runner.clone());
859
860        let paged = provider.list(None).await.expect("should list");
861
862        assert!(paged.items.is_empty());
863        let calls = runner.recorded_calls();
864        assert_eq!(calls.len(), 1);
865        assert!(!calls[0].1.iter().any(|a| a == "--limit"));
866        assert!(calls[0].1.iter().any(|a| a == "--per-page"));
867        assert!(calls[0].1.iter().any(|a| a == "--page"));
868    }
869
870    #[tokio::test]
871    async fn test_should_route_milestone_list_through_runner() {
872        let runner = MockCommandRunner::success("[]");
873        let provider = GitCodeMilestoneProvider::with_runner("owner/repo", runner.clone());
874
875        let paged = provider.list(None).await.expect("should list");
876
877        assert!(paged.items.is_empty());
878        let calls = runner.recorded_calls();
879        assert_eq!(calls.len(), 1);
880        assert!(!calls[0].1.iter().any(|a| a == "--limit"));
881        assert!(calls[0].1.iter().any(|a| a == "--per-page"));
882        assert!(calls[0].1.iter().any(|a| a == "--page"));
883    }
884
885    #[tokio::test]
886    async fn test_should_produce_complete_argv_for_gitcode_label_list_with_default_limit() {
887        let runner = MockCommandRunner::success("[]");
888        let provider = GitCodeLabelProvider::with_runner("owner/repo", runner.clone());
889
890        let paged = provider.list(None).await.expect("should list");
891
892        assert!(paged.items.is_empty());
893        assert_eq!(runner.recorded_calls()[0].0, crate::gitcode_binary());
894        assert_eq!(
895            runner.recorded_calls()[0].1,
896            vec![
897                "label",
898                "list",
899                "-R",
900                "owner/repo",
901                "--json",
902                "--per-page",
903                "100",
904                "--page",
905                "1"
906            ]
907            .into_iter()
908            .map(String::from)
909            .collect::<Vec<_>>()
910        );
911    }
912
913    #[tokio::test]
914    async fn test_should_produce_complete_argv_for_gitcode_milestone_list_with_default_limit() {
915        let runner = MockCommandRunner::success("[]");
916        let provider = GitCodeMilestoneProvider::with_runner("owner/repo", runner.clone());
917
918        let paged = provider.list(None).await.expect("should list");
919
920        assert!(paged.items.is_empty());
921        assert_eq!(runner.recorded_calls()[0].0, crate::gitcode_binary());
922        assert_eq!(
923            runner.recorded_calls()[0].1,
924            vec![
925                "milestone",
926                "list",
927                "-R",
928                "owner/repo",
929                "--json",
930                "--per-page",
931                "100",
932                "--page",
933                "1"
934            ]
935            .into_iter()
936            .map(String::from)
937            .collect::<Vec<_>>()
938        );
939    }
940}