1use 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#[derive(Debug, Clone)]
34pub struct GitCodeLabelProvider<R: CommandRunner = RealCommandRunner> {
35 repo: String,
37 runner: R,
39}
40
41impl GitCodeLabelProvider<RealCommandRunner> {
42 #[must_use]
46 pub fn new(repo: impl Into<String>) -> Self {
47 Self {
48 repo: repo.into(),
49 runner: RealCommandRunner,
50 }
51 }
52
53 #[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 #[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
79const 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 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 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 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#[derive(Debug, Clone)]
262pub struct GitCodeMilestoneProvider<R: CommandRunner = RealCommandRunner> {
263 repo: String,
265 runner: R,
267}
268
269impl GitCodeMilestoneProvider<RealCommandRunner> {
270 #[must_use]
274 pub fn new(repo: impl Into<String>) -> Self {
275 Self {
276 repo: repo.into(),
277 runner: RealCommandRunner,
278 }
279 }
280
281 #[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 #[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#[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 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 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 #[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 #[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 #[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 #[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 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 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 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 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}