Skip to main content

gitflow_gitlab/
label.rs

1//! GitLab Label 和 Milestone 提供者实现。
2//!
3//! 通过 `glab label` 和 `glab milestone` 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, 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    GITLAB_MAX_PER_PAGE,
21    error::parse_glab_error,
22    runner::{CommandRunner, RealCommandRunner},
23};
24
25/// 在写操作后的读回分页结果中按 `predicate` 定位刚写入的条目。
26///
27/// 写操作(create/edit/close/reopen)已经成功执行,紧接着的读回只是为了
28/// 把写回的完整数据返回给调用方。若读回被截断,说明该条目**很可能已经
29/// 写入成功**,只是不在读回抓到的前 N 条内——此时必须报告"截断"而不是
30/// "未找到",否则会让用户以为已经成功的写操作失败了。
31///
32/// # Errors
33///
34/// 读回被截断时返回 `truncated_msg`;未截断但 `predicate` 未命中任何条目
35/// 时返回 `not_found_msg`(理论上不应发生,除非平台侧的读回与写回不一致)。
36fn resolve_after_mutation<T>(
37    paged: Paged<T>,
38    predicate: impl Fn(&T) -> bool,
39    truncated_msg: &str,
40    not_found_msg: String,
41) -> Result<T> {
42    if paged.truncated {
43        return Err(CoreError::Platform(truncated_msg.to_string()));
44    }
45    paged
46        .items
47        .into_iter()
48        .find(predicate)
49        .ok_or(CoreError::Platform(not_found_msg))
50}
51
52/// 把标签颜色归一化为带 `#` 前缀的十六进制格式。
53///
54/// GitLab 的颜色约定要求 `#` 前缀(如 `#d73a4a`),但 CLI 允许调用方省略它。
55/// 归一化前先 trim 首尾空白,避免 `" d73a4a"` 这类输入被拼成 `"# d73a4a"`。
56fn normalize_label_color(color: &str) -> String {
57    let trimmed = color.trim();
58    if trimmed.starts_with('#') {
59        trimmed.to_string()
60    } else {
61        format!("#{trimmed}")
62    }
63}
64
65/// GitLab Label 提供者,通过 `glab` CLI 管理仓库标签。
66///
67/// # Examples
68///
69/// ```no_run
70/// use gitflow_gitlab::GitLabLabelProvider;
71///
72/// let provider = GitLabLabelProvider::new("gitlab-org/gitlab");
73/// ```
74#[derive(Debug, Clone)]
75pub struct GitLabLabelProvider<R: CommandRunner = RealCommandRunner> {
76    /// GitLab `namespace/project`。
77    repo: String,
78    /// 传给 `glab label ...` 子命令 `--repo` 参数的目标字符串。默认等于
79    /// `repo`;通过 [`with_remote_url`](GitLabLabelProvider::with_remote_url)
80    /// 构造时为完整 git remote URL,用于在自建 GitLab 实例上显式锁定 host。
81    repo_target: String,
82    /// 用于执行 `glab` CLI 命令的 runner。
83    runner: R,
84}
85
86impl GitLabLabelProvider<RealCommandRunner> {
87    /// 创建新的 GitLab Label 提供者。
88    ///
89    /// `repo` 格式为 `namespace/project`。
90    #[must_use]
91    pub fn new(repo: impl Into<String>) -> GitLabLabelProvider<RealCommandRunner> {
92        let repo = repo.into();
93        GitLabLabelProvider {
94            repo_target: repo.clone(),
95            repo,
96            runner: RealCommandRunner,
97        }
98    }
99
100    /// Create a new provider from a shared [`Session`].
101    ///
102    /// This enables state reuse across multiple operations in workflow chains.
103    #[must_use]
104    pub fn with_session(session: &gitflow_core::Session) -> Self {
105        let repo = session.repo.clone();
106        Self {
107            repo_target: repo.clone(),
108            repo,
109            runner: RealCommandRunner,
110        }
111    }
112
113    /// 使用完整 git remote URL 作为 `glab label ...` 的 `--repo` 目标创建提供者。
114    #[must_use]
115    pub fn with_remote_url(repo: impl Into<String>, remote_url: impl Into<String>) -> Self {
116        Self {
117            repo: repo.into(),
118            repo_target: remote_url.into(),
119            runner: RealCommandRunner,
120        }
121    }
122}
123
124impl<R: CommandRunner> GitLabLabelProvider<R> {
125    /// 使用自定义 [`CommandRunner`] 创建提供者。
126    ///
127    /// 主要用于测试,可注入模拟 runner 以控制 `glab` CLI 的输出。
128    /// `repo` 格式为 `namespace/project`。
129    #[must_use]
130    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
131        let repo = repo.into();
132        Self {
133            repo_target: repo.clone(),
134            repo,
135            runner,
136        }
137    }
138
139    /// 使用自定义 [`CommandRunner`] 并显式指定 `--repo` 目标创建提供者。
140    ///
141    /// 主要用于测试,验证 `repo_target`(如完整 remote URL)被正确传给 `glab`。
142    #[must_use]
143    pub fn with_runner_and_repo_target(
144        repo: impl Into<String>,
145        repo_target: impl Into<String>,
146        runner: R,
147    ) -> Self {
148        Self {
149            repo: repo.into(),
150            repo_target: repo_target.into(),
151            runner,
152        }
153    }
154}
155
156/// 拉取一页 `glab label list --output json` 的原始 API 响应。
157///
158/// 提取为自由函数(而非 `&self` 方法),以便在 [`fetch_capped`] 的闭包中
159/// 通过借用的 `runner`/`repo_target` 调用,避免闭包捕获 `self` 触发
160/// `async_trait` 装箱后的 `Send` 推导问题。
161///
162/// # Errors
163///
164/// 当 `glab` CLI 调用失败或响应解析失败时返回错误。
165async fn fetch_label_page<R: CommandRunner>(
166    runner: &R,
167    repo_target: &str,
168    page: u32,
169    per_page: u32,
170) -> Result<Vec<LabelApiResponse>> {
171    let page_str = page.to_string();
172    let per_page_str = per_page.to_string();
173
174    let output = runner
175        .run(
176            "glab",
177            &[
178                "label",
179                "list",
180                "--repo",
181                repo_target,
182                "--output",
183                "json",
184                "--per-page",
185                &per_page_str,
186                "--page",
187                &page_str,
188            ],
189        )
190        .await
191        .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label list: {e}")))?;
192
193    if !output.status.success() {
194        return Err(parse_glab_error(&output.stderr).into());
195    }
196
197    serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)
198}
199
200/// `glab label --output json` 返回的 JSON 结构。
201#[derive(Debug, Clone, Deserialize)]
202struct LabelApiResponse {
203    #[serde(default)]
204    id: u64,
205    #[serde(default)]
206    name: String,
207    #[serde(default)]
208    color: Option<String>,
209    #[serde(default)]
210    description: Option<String>,
211}
212
213impl From<LabelApiResponse> for LabelData {
214    fn from(api: LabelApiResponse) -> Self {
215        Self {
216            name: api.name,
217            color: api.color,
218            description: api.description,
219        }
220    }
221}
222
223#[async_trait]
224impl<R: CommandRunner + 'static> LabelProvider for GitLabLabelProvider<R> {
225    async fn create(&self, args: CreateLabelArgs) -> Result<LabelData> {
226        let color = normalize_label_color(&args.color);
227
228        debug!(
229            repo = %self.repo,
230            name = %args.name,
231            color = %color,
232            "spawning `glab label create`"
233        );
234
235        let mut cmd_args: Vec<&str> = vec![
236            "label",
237            "create",
238            "--name",
239            &args.name,
240            "--color",
241            &color,
242            "--repo",
243            &self.repo_target,
244        ];
245
246        if let Some(ref desc) = args.description {
247            cmd_args.push("--description");
248            cmd_args.push(desc);
249        }
250
251        let output =
252            self.runner.run("glab", &cmd_args).await.map_err(|e| {
253                CoreError::Platform(format!("Failed to spawn glab label create: {e}"))
254            })?;
255
256        if !output.status.success() {
257            return Err(parse_glab_error(&output.stderr).into());
258        }
259
260        let paged = self.list(None).await?;
261        resolve_after_mutation(
262            paged,
263            |l| l.name == args.name,
264            "label lookup truncated after create; too many labels to confirm the write landed",
265            format!("Label '{}' not found after create", args.name),
266        )
267    }
268
269    async fn list(&self, limit: Option<u32>) -> Result<Paged<LabelData>> {
270        let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
271        let repo_target = &self.repo_target;
272        let runner = &self.runner;
273        let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
274
275        debug!(repo = %self.repo, cap, "spawning `glab label list`");
276
277        fetch_capped(
278            FetchStrategy::Paged { per_page },
279            cap,
280            |page, per_page| async move {
281                let api_responses = fetch_label_page(runner, repo_target, page, per_page).await?;
282                Ok(api_responses.into_iter().map(LabelData::from).collect())
283            },
284        )
285        .await
286    }
287
288    async fn edit(&self, name: &str, args: CreateLabelArgs) -> Result<LabelData> {
289        // 名称 → id 解析必须看到完整标签集合,否则截断会导致把"存在但不在
290        // 前 N 条内"的标签误判为不存在。因此这里固定请求
291        // `DEFAULT_LIST_LIMIT` 的完整上限,而不是转发调用方的分页 `limit`,
292        // 并在被截断时报错而非静默使用不完整集合。
293        let cap = DEFAULT_LIST_LIMIT;
294        let repo_target = &self.repo_target;
295        let runner = &self.runner;
296        let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
297
298        let paged =
299            fetch_capped(
300                FetchStrategy::Paged { per_page },
301                cap,
302                |page, per_page| async move {
303                    fetch_label_page(runner, repo_target, page, per_page).await
304                },
305            )
306            .await?;
307
308        if paged.truncated {
309            return Err(CoreError::Platform(
310                "label lookup truncated; too many labels to resolve by name".into(),
311            ));
312        }
313
314        let label_id = paged
315            .items
316            .iter()
317            .find(|l| l.name == name)
318            .map(|l| l.id)
319            .ok_or_else(|| CoreError::Platform(format!("Label '{name}' not found")))?;
320
321        debug!(
322            repo = %self.repo,
323            name,
324            label_id,
325            new_name = %args.name,
326            "spawning `glab label edit --label-id`"
327        );
328
329        let id_str = label_id.to_string();
330        let color = normalize_label_color(&args.color);
331        let mut cmd_args: Vec<&str> = vec![
332            "label",
333            "edit",
334            "--label-id",
335            &id_str,
336            "--repo",
337            &self.repo_target,
338            "--new-name",
339            &args.name,
340            "--color",
341            &color,
342        ];
343        if let Some(ref desc) = args.description {
344            cmd_args.push("--description");
345            cmd_args.push(desc);
346        }
347        let output =
348            self.runner.run("glab", &cmd_args).await.map_err(|e| {
349                CoreError::Platform(format!("Failed to spawn glab label edit: {e}"))
350            })?;
351        if !output.status.success() {
352            return Err(parse_glab_error(&output.stderr).into());
353        }
354
355        let paged = self.list(None).await?;
356        resolve_after_mutation(
357            paged,
358            |l| l.name == args.name,
359            "label lookup truncated after edit; too many labels to confirm the write landed",
360            format!("Label '{}' not found after edit", args.name),
361        )
362    }
363
364    async fn delete(&self, name: &str) -> Result<()> {
365        debug!(repo = %self.repo, name, "spawning `glab label delete`");
366
367        let output = self
368            .runner
369            .run(
370                "glab",
371                &["label", "delete", name, "--repo", &self.repo_target],
372            )
373            .await
374            .map_err(|e| CoreError::Platform(format!("Failed to spawn glab label delete: {e}")))?;
375
376        if !output.status.success() {
377            return Err(parse_glab_error(&output.stderr).into());
378        }
379
380        Ok(())
381    }
382}
383
384// ── Milestone Provider ──────────────────────────────────────────────
385
386/// GitLab 里程碑提供者,通过 `glab milestone` 管理仓库里程碑。
387///
388/// # Examples
389///
390/// ```no_run
391/// use gitflow_gitlab::GitLabMilestoneProvider;
392///
393/// let provider = GitLabMilestoneProvider::new("gitlab-org/gitlab");
394/// ```
395#[derive(Debug, Clone)]
396pub struct GitLabMilestoneProvider<R: CommandRunner = RealCommandRunner> {
397    /// GitLab `namespace/project`。
398    repo: String,
399    /// 传给 `glab milestone ...` 子命令 `--project` 参数的目标字符串
400    /// (`glab milestone` 用 `--project` 而非 `--repo`,语义与其余 provider
401    /// 的 `repo_target` 一致,仅 flag 名不同)。
402    project_target: String,
403    /// 用于执行 `glab` CLI 命令的 runner。
404    runner: R,
405}
406
407impl GitLabMilestoneProvider<RealCommandRunner> {
408    /// 创建新的 GitLab Milestone 提供者。
409    ///
410    /// `repo` 格式为 `namespace/project`。
411    #[must_use]
412    pub fn new(repo: impl Into<String>) -> GitLabMilestoneProvider<RealCommandRunner> {
413        let repo = repo.into();
414        GitLabMilestoneProvider {
415            project_target: repo.clone(),
416            repo,
417            runner: RealCommandRunner,
418        }
419    }
420
421    /// Create a new provider from a shared [`Session`].
422    ///
423    /// This enables state reuse across multiple operations in workflow chains.
424    #[must_use]
425    pub fn with_session(session: &gitflow_core::Session) -> Self {
426        let repo = session.repo.clone();
427        Self {
428            project_target: repo.clone(),
429            repo,
430            runner: RealCommandRunner,
431        }
432    }
433}
434
435impl<R: CommandRunner> GitLabMilestoneProvider<R> {
436    /// 使用自定义 [`CommandRunner`] 创建提供者。
437    ///
438    /// 主要用于测试,可注入模拟 runner 以控制 `glab` CLI 的输出。
439    /// `repo` 格式为 `namespace/project`。
440    #[must_use]
441    pub fn with_runner(repo: impl Into<String>, runner: R) -> Self {
442        let repo = repo.into();
443        Self {
444            project_target: repo.clone(),
445            repo,
446            runner,
447        }
448    }
449
450    /// 使用自定义 [`CommandRunner`] 并显式指定 `--project` 目标创建提供者。
451    ///
452    /// 主要用于测试,验证 `project_target`(如完整 remote URL)被正确传给 `glab`。
453    #[must_use]
454    pub fn with_runner_and_project_target(
455        repo: impl Into<String>,
456        project_target: impl Into<String>,
457        runner: R,
458    ) -> Self {
459        Self {
460            repo: repo.into(),
461            project_target: project_target.into(),
462            runner,
463        }
464    }
465}
466
467/// `glab milestone --output json` 返回的 JSON 结构。
468#[derive(Debug, Clone, Deserialize)]
469#[allow(
470    dead_code,
471    reason = "Used for deserialization; not all fields are read"
472)]
473struct MilestoneApiResponse {
474    id: u64,
475    #[serde(default)]
476    iid: Option<u64>,
477    title: String,
478    #[serde(default)]
479    description: Option<String>,
480    state: String,
481    #[serde(default)]
482    due_date: Option<String>,
483    #[serde(default)]
484    start_date: Option<String>,
485    #[serde(default)]
486    created_at: Option<DateTime<Utc>>,
487    #[serde(default)]
488    updated_at: Option<DateTime<Utc>>,
489}
490
491impl From<MilestoneApiResponse> for MilestoneData {
492    fn from(api: MilestoneApiResponse) -> Self {
493        let state = if api.state == "closed" {
494            State::Closed
495        } else {
496            State::Open
497        };
498        let due_on = api.due_date.and_then(|s| {
499            // GitLab returns due_date as "YYYY-MM-DD" or ISO 8601
500            if let Ok(dt) = DateTime::parse_from_rfc3339(&s) {
501                return Some(dt.with_timezone(&Utc));
502            }
503            chrono::NaiveDate::parse_from_str(&s, "%Y-%m-%d")
504                .ok()
505                .map(|d| {
506                    let naive_dt = d
507                        .and_hms_opt(0, 0, 0)
508                        .unwrap_or_else(|| d.and_hms_opt(12, 0, 0).unwrap_or_default());
509                    DateTime::<Utc>::from_naive_utc_and_offset(naive_dt, Utc)
510                })
511        });
512
513        Self {
514            number: api.iid.unwrap_or(api.id),
515            title: api.title,
516            description: api.description,
517            state,
518            due_on,
519            closed_issues: 0,
520            open_issues: 0,
521        }
522    }
523}
524
525/// 拉取一页 `glab milestone list --output json` 的原始 API 响应。
526///
527/// 与 [`fetch_label_page`] 同理提取为自由函数,避免闭包捕获 `self`。
528///
529/// # Errors
530///
531/// 当 `glab` CLI 调用失败或响应解析失败时返回错误。
532async fn fetch_milestone_page<R: CommandRunner>(
533    runner: &R,
534    project_target: &str,
535    page: u32,
536    per_page: u32,
537) -> Result<Vec<MilestoneApiResponse>> {
538    let page_str = page.to_string();
539    let per_page_str = per_page.to_string();
540
541    let output = runner
542        .run(
543            "glab",
544            &[
545                "milestone",
546                "list",
547                "--project",
548                project_target,
549                "--output",
550                "json",
551                "--per-page",
552                &per_page_str,
553                "--page",
554                &page_str,
555            ],
556        )
557        .await
558        .map_err(|e| CoreError::Platform(format!("Failed to spawn glab milestone list: {e}")))?;
559
560    if !output.status.success() {
561        return Err(parse_glab_error(&output.stderr).into());
562    }
563
564    serde_json::from_slice(&output.stdout).map_err(CoreError::Serialization)
565}
566
567#[async_trait]
568impl<R: CommandRunner + 'static> MilestoneProvider for GitLabMilestoneProvider<R> {
569    async fn create(&self, args: CreateMilestoneArgs) -> Result<MilestoneData> {
570        debug!(repo = %self.repo, title = %args.title, "spawning `glab milestone create`");
571
572        let due_arg = args
573            .due_on
574            .as_ref()
575            .map(|due| due.format("%Y-%m-%d").to_string());
576
577        let mut cmd_args: Vec<&str> = vec![
578            "milestone",
579            "create",
580            "--title",
581            &args.title,
582            "--project",
583            &self.project_target,
584        ];
585
586        if let Some(ref desc) = args.description {
587            cmd_args.push("--description");
588            cmd_args.push(desc);
589        }
590
591        if let Some(ref due_str) = due_arg {
592            cmd_args.push("--due-date");
593            cmd_args.push(due_str);
594        }
595
596        let output = self.runner.run("glab", &cmd_args).await.map_err(|e| {
597            CoreError::Platform(format!("Failed to spawn glab milestone create: {e}"))
598        })?;
599
600        if !output.status.success() {
601            return Err(parse_glab_error(&output.stderr).into());
602        }
603
604        let paged = self.list(None).await?;
605        resolve_after_mutation(
606            paged,
607            |m| m.title == args.title,
608            "milestone lookup truncated after create; too many milestones to confirm the write \
609             landed",
610            "Milestone not found after create".into(),
611        )
612    }
613
614    async fn list(&self, limit: Option<u32>) -> Result<Paged<MilestoneData>> {
615        let cap = limit.unwrap_or(DEFAULT_LIST_LIMIT);
616        let project_target = &self.project_target;
617        let runner = &self.runner;
618        let per_page = cap.saturating_add(1).min(GITLAB_MAX_PER_PAGE);
619
620        debug!(repo = %self.repo, cap, "spawning `glab milestone list`");
621
622        fetch_capped(
623            FetchStrategy::Paged { per_page },
624            cap,
625            |page, per_page| async move {
626                let api_responses =
627                    fetch_milestone_page(runner, project_target, page, per_page).await?;
628                Ok(api_responses.into_iter().map(MilestoneData::from).collect())
629            },
630        )
631        .await
632    }
633
634    async fn edit(&self, number: u64, args: CreateMilestoneArgs) -> Result<MilestoneData> {
635        debug!(repo = %self.repo, number, "spawning `glab milestone edit`");
636
637        let due_arg = args
638            .due_on
639            .as_ref()
640            .map(|due| due.format("%Y-%m-%d").to_string());
641        let number_str = number.to_string();
642
643        let mut cmd_args: Vec<&str> = vec![
644            "milestone",
645            "edit",
646            &number_str,
647            "--project",
648            &self.project_target,
649            "--title",
650            &args.title,
651        ];
652
653        if let Some(ref desc) = args.description {
654            cmd_args.push("--description");
655            cmd_args.push(desc);
656        }
657
658        if let Some(ref due_str) = due_arg {
659            cmd_args.push("--due-date");
660            cmd_args.push(due_str);
661        }
662
663        let output = self.runner.run("glab", &cmd_args).await.map_err(|e| {
664            CoreError::Platform(format!("Failed to spawn glab milestone edit: {e}"))
665        })?;
666
667        if !output.status.success() {
668            return Err(parse_glab_error(&output.stderr).into());
669        }
670
671        let paged = self.list(None).await?;
672        resolve_after_mutation(
673            paged,
674            |m| m.title == args.title || m.number == number,
675            "milestone lookup truncated after edit; too many milestones to confirm the write \
676             landed",
677            "Milestone not found after edit".into(),
678        )
679    }
680
681    async fn close(&self, number: u64) -> Result<MilestoneData> {
682        debug!(
683            repo = %self.repo,
684            number,
685            "spawning `glab milestone edit --state close`"
686        );
687
688        let number_str = number.to_string();
689        let output = self
690            .runner
691            .run(
692                "glab",
693                &[
694                    "milestone",
695                    "edit",
696                    &number_str,
697                    "--state",
698                    "close",
699                    "--project",
700                    &self.project_target,
701                ],
702            )
703            .await
704            .map_err(|e| {
705                CoreError::Platform(format!("Failed to spawn glab milestone edit: {e}"))
706            })?;
707
708        if !output.status.success() {
709            return Err(parse_glab_error(&output.stderr).into());
710        }
711
712        let paged = self.list(None).await?;
713        resolve_after_mutation(
714            paged,
715            |m| m.number == number,
716            "milestone lookup truncated after close; too many milestones to confirm the write \
717             landed",
718            "Milestone not found after close".into(),
719        )
720    }
721
722    async fn reopen(&self, number: u64) -> Result<MilestoneData> {
723        debug!(
724            repo = %self.repo,
725            number,
726            "spawning `glab milestone edit --state activate`"
727        );
728
729        let number_str = number.to_string();
730        let output = self
731            .runner
732            .run(
733                "glab",
734                &[
735                    "milestone",
736                    "edit",
737                    &number_str,
738                    "--state",
739                    "activate",
740                    "--project",
741                    &self.project_target,
742                ],
743            )
744            .await
745            .map_err(|e| {
746                CoreError::Platform(format!("Failed to spawn glab milestone edit: {e}"))
747            })?;
748
749        if !output.status.success() {
750            return Err(parse_glab_error(&output.stderr).into());
751        }
752
753        let paged = self.list(None).await?;
754        resolve_after_mutation(
755            paged,
756            |m| m.number == number,
757            "milestone lookup truncated after reopen; too many milestones to confirm the write \
758             landed",
759            "Milestone not found after reopen".into(),
760        )
761    }
762}
763
764#[cfg(test)]
765mod tests {
766    use super::*;
767    use crate::runner::{MockCommandRunner, SequencedMockCommandRunner};
768
769    // --- GitLabLabelProvider tests ---
770
771    #[test]
772    fn test_should_construct_gitlab_label_provider() {
773        let provider = GitLabLabelProvider::new("gitlab-org/gitlab");
774        assert_eq!(provider.repo, "gitlab-org/gitlab");
775    }
776
777    #[test]
778    fn test_should_construct_gitlab_label_provider_from_string() {
779        let repo = String::from("gitlab-org/gitlab");
780        let provider = GitLabLabelProvider::new(repo);
781        assert_eq!(provider.repo, "gitlab-org/gitlab");
782    }
783
784    #[tokio::test]
785    async fn test_should_use_explicit_repo_target_for_delete() {
786        let runner = MockCommandRunner::success("");
787        let provider = GitLabLabelProvider::with_runner_and_repo_target(
788            "owner/repo",
789            "https://192.168.230.23/iproost/proxy/api-src.git",
790            runner.clone(),
791        );
792
793        let result = provider.delete("bug").await;
794
795        assert!(result.is_ok(), "expected Ok, got {result:?}");
796        assert_eq!(
797            runner.recorded_calls()[0].1,
798            vec![
799                "label",
800                "delete",
801                "bug",
802                "--repo",
803                "https://192.168.230.23/iproost/proxy/api-src.git",
804            ]
805            .into_iter()
806            .map(String::from)
807            .collect::<Vec<_>>()
808        );
809    }
810
811    #[test]
812    fn test_should_debug_format_label_provider() {
813        let provider = GitLabLabelProvider::new("owner/repo");
814        let debug = format!("{provider:?}");
815        assert!(debug.contains("GitLabLabelProvider"));
816        assert!(debug.contains("owner/repo"));
817    }
818
819    #[test]
820    fn test_should_clone_gitlab_label_provider() {
821        let original = GitLabLabelProvider::new("owner/repo");
822        let cloned = original.clone();
823        assert_eq!(original.repo, cloned.repo);
824    }
825
826    // --- LabelData deserialization tests ---
827
828    #[test]
829    fn test_should_deserialize_label_api_response() {
830        let json = br##"{
831            "name": "bug",
832            "color": "#d73a4a",
833            "description": "Something isn't working"
834        }"##;
835
836        let api: LabelApiResponse = serde_json::from_slice(json).expect("valid LabelApiResponse");
837        let label: LabelData = api.into();
838        assert_eq!(label.name, "bug");
839        assert_eq!(label.color.as_deref(), Some("#d73a4a"));
840        assert_eq!(
841            label.description.as_deref(),
842            Some("Something isn't working")
843        );
844    }
845
846    #[test]
847    fn test_should_deserialize_label_list() {
848        let json = br##"[
849            {"name": "bug", "color": "#d73a4a", "description": "Bug"},
850            {"name": "feature", "color": "#0075ca", "description": null}
851        ]"##;
852
853        let list: Vec<LabelApiResponse> = serde_json::from_slice(json).expect("valid label list");
854        assert_eq!(list.len(), 2);
855        assert_eq!(list[0].name, "bug");
856        assert_eq!(list[1].name, "feature");
857    }
858
859    #[test]
860    fn test_should_deserialize_empty_label_list() {
861        let json = b"[]";
862        let list: Vec<LabelApiResponse> = serde_json::from_slice(json).expect("valid empty list");
863        assert!(list.is_empty());
864    }
865
866    // --- GitLabMilestoneProvider tests ---
867
868    #[test]
869    fn test_should_construct_gitlab_milestone_provider() {
870        let provider = GitLabMilestoneProvider::new("gitlab-org/gitlab");
871        assert_eq!(provider.repo, "gitlab-org/gitlab");
872    }
873
874    #[tokio::test]
875    async fn test_should_use_explicit_project_target_for_close() {
876        let runner = SequencedMockCommandRunner::from_results(&[
877            (true, ""),
878            (
879                true,
880                r#"[{"id":1,"iid":3,"title":"v1.0","description":null,"state":"closed","due_date":null,"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-01T00:00:00Z"}]"#,
881            ),
882        ]);
883        let provider = GitLabMilestoneProvider::with_runner_and_project_target(
884            "owner/repo",
885            "https://192.168.230.23/iproost/proxy/api-src.git",
886            runner.clone(),
887        );
888
889        let ms = provider.close(3).await.expect("close should succeed");
890
891        assert_eq!(ms.number, 3);
892        assert_eq!(
893            runner.recorded_calls()[0].1,
894            vec![
895                "milestone",
896                "edit",
897                "3",
898                "--state",
899                "close",
900                "--project",
901                "https://192.168.230.23/iproost/proxy/api-src.git",
902            ]
903            .into_iter()
904            .map(String::from)
905            .collect::<Vec<_>>()
906        );
907    }
908
909    #[test]
910    fn test_should_debug_format_milestone_provider() {
911        let provider = GitLabMilestoneProvider::new("owner/repo");
912        let debug = format!("{provider:?}");
913        assert!(debug.contains("GitLabMilestoneProvider"));
914        assert!(debug.contains("owner/repo"));
915    }
916
917    #[test]
918    fn test_should_clone_gitlab_milestone_provider() {
919        let original = GitLabMilestoneProvider::new("owner/repo");
920        let cloned = original.clone();
921        assert_eq!(original.repo, cloned.repo);
922    }
923
924    // --- Failure-path tests using an injected MockCommandRunner ---
925
926    #[tokio::test]
927    async fn test_should_fail_when_label_create_glab_fails() {
928        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
929        let provider = GitLabLabelProvider::with_runner("owner/repo", runner);
930        let args = CreateLabelArgs {
931            name: "bug".to_string(),
932            color: "#d73a4a".to_string(),
933            description: None,
934        };
935        let result = provider.create(args).await;
936        assert!(result.is_err());
937    }
938
939    #[tokio::test]
940    async fn test_should_fail_when_milestone_create_glab_fails() {
941        let runner = MockCommandRunner::failure(r#"{"message": "Forbidden"}"#, 256);
942        let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner);
943        let args = CreateMilestoneArgs {
944            title: "v1.0".to_string(),
945            description: None,
946            due_on: None,
947        };
948        let result = provider.create(args).await;
949        assert!(result.is_err());
950    }
951
952    #[tokio::test]
953    async fn test_should_create_label_without_output_json_and_refetch_via_list() {
954        let runner = SequencedMockCommandRunner::from_results(&[
955            (true, ""), // label create 成功(stdout 为纯文本,忽略)
956            (true, r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##), // list 找回
957        ]);
958        let provider = GitLabLabelProvider::with_runner("owner/repo", runner);
959
960        let args = CreateLabelArgs {
961            name: "bug".to_string(),
962            color: "#d73a4a".to_string(),
963            description: None,
964        };
965
966        let label = provider.create(args).await.expect("should create");
967
968        assert_eq!(label.name, "bug");
969    }
970
971    #[tokio::test]
972    async fn test_should_normalize_color_without_hash_prefix() {
973        let runner = SequencedMockCommandRunner::from_results(&[
974            (true, ""),
975            (true, r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##),
976        ]);
977        let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
978
979        let args = CreateLabelArgs {
980            name: "bug".to_string(),
981            color: "d73a4a".to_string(), // 无 # 前缀
982            description: None,
983        };
984
985        provider.create(args).await.expect("should create");
986
987        let calls = runner.recorded_calls();
988        let create_call = &calls[0];
989        let color_idx = create_call
990            .1
991            .iter()
992            .position(|a| a == "--color")
993            .expect("--color flag present");
994        assert_eq!(create_call.1[color_idx + 1], "#d73a4a");
995    }
996
997    #[tokio::test]
998    async fn test_should_pass_through_color_that_already_has_hash_prefix() {
999        let runner = SequencedMockCommandRunner::from_results(&[
1000            (true, ""),
1001            (true, r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##),
1002        ]);
1003        let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
1004
1005        let args = CreateLabelArgs {
1006            name: "bug".to_string(),
1007            color: "#d73a4a".to_string(), // 已带 #
1008            description: None,
1009        };
1010
1011        provider.create(args).await.expect("should create");
1012
1013        let calls = runner.recorded_calls();
1014        let create_call = &calls[0];
1015        let color_idx = create_call
1016            .1
1017            .iter()
1018            .position(|a| a == "--color")
1019            .expect("--color flag present");
1020        assert_eq!(create_call.1[color_idx + 1], "#d73a4a");
1021    }
1022
1023    #[tokio::test]
1024    async fn test_should_edit_label_with_label_id() {
1025        let list_json = r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##;
1026        let edited_json = r##"[{"id":101,"name":"critical","color":"#d73a4a"}]"##;
1027        let runner = SequencedMockCommandRunner::from_results(&[
1028            (true, list_json),   // list_api 解析 id
1029            (true, edited_json), // label edit 成功(stdout 为纯文本,忽略)
1030            (true, edited_json), // 再次 list 找回
1031        ]);
1032        let provider = GitLabLabelProvider::with_runner("owner/repo", runner);
1033
1034        let args = CreateLabelArgs {
1035            name: "critical".to_string(),
1036            color: "#d73a4a".to_string(),
1037            description: None,
1038        };
1039
1040        let label = provider.edit("bug", args).await.expect("should edit");
1041
1042        assert_eq!(label.name, "critical");
1043    }
1044
1045    #[tokio::test]
1046    async fn test_should_normalize_color_without_hash_prefix_on_edit() {
1047        let list_json = r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##;
1048        let edited_json = r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##;
1049        let runner = SequencedMockCommandRunner::from_results(&[
1050            (true, list_json),
1051            (true, edited_json),
1052            (true, edited_json),
1053        ]);
1054        let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
1055
1056        let args = CreateLabelArgs {
1057            name: "bug".to_string(),
1058            color: "d73a4a".to_string(), // 无 # 前缀
1059            description: None,
1060        };
1061
1062        provider.edit("bug", args).await.expect("should edit");
1063
1064        let calls = runner.recorded_calls();
1065        let edit_call = &calls[1];
1066        let color_idx = edit_call
1067            .1
1068            .iter()
1069            .position(|a| a == "--color")
1070            .expect("--color flag present");
1071        assert_eq!(edit_call.1[color_idx + 1], "#d73a4a");
1072    }
1073
1074    #[tokio::test]
1075    async fn test_should_trim_whitespace_before_normalizing_color() {
1076        let runner = SequencedMockCommandRunner::from_results(&[
1077            (true, ""),
1078            (true, r##"[{"id":101,"name":"bug","color":"#d73a4a"}]"##),
1079        ]);
1080        let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
1081
1082        let args = CreateLabelArgs {
1083            name: "bug".to_string(),
1084            color: "  d73a4a  ".to_string(),
1085            description: None,
1086        };
1087
1088        provider.create(args).await.expect("should create");
1089
1090        let calls = runner.recorded_calls();
1091        let color_idx = calls[0]
1092            .1
1093            .iter()
1094            .position(|a| a == "--color")
1095            .expect("--color flag present");
1096        assert_eq!(calls[0].1[color_idx + 1], "#d73a4a");
1097    }
1098
1099    #[tokio::test]
1100    async fn test_should_delete_label_without_yes_flag() {
1101        let runner = MockCommandRunner::success("");
1102        let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
1103
1104        provider.delete("bug").await.expect("should delete");
1105
1106        assert_eq!(
1107            runner.recorded_calls()[0].1,
1108            vec!["label", "delete", "bug", "--repo", "owner/repo"]
1109                .into_iter()
1110                .map(String::from)
1111                .collect::<Vec<_>>()
1112        );
1113    }
1114
1115    #[tokio::test]
1116    async fn test_should_create_milestone_without_output_json_and_refetch() {
1117        let runner = SequencedMockCommandRunner::from_results(&[
1118            (true, ""), // milestone create 成功(stdout 为纯文本,忽略)
1119            (
1120                true,
1121                r#"[{"id":1,"iid":3,"title":"v1.0","description":null,"state":"active","due_date":null,"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-01T00:00:00Z"}]"#,
1122            ),
1123        ]);
1124        let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner);
1125
1126        let args = CreateMilestoneArgs {
1127            title: "v1.0".to_string(),
1128            description: None,
1129            due_on: None,
1130        };
1131
1132        let ms = provider.create(args).await.expect("should create");
1133
1134        assert_eq!(ms.number, 3);
1135        assert_eq!(ms.title, "v1.0");
1136    }
1137
1138    #[tokio::test]
1139    async fn test_should_edit_milestone_without_output_json_and_refetch() {
1140        let runner = SequencedMockCommandRunner::from_results(&[
1141            (true, ""), // milestone edit 成功
1142            (
1143                true,
1144                r#"[{"id":1,"iid":3,"title":"v1.1","description":null,"state":"active","due_date":null,"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-01T00:00:00Z"}]"#,
1145            ),
1146        ]);
1147        let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner);
1148
1149        let args = CreateMilestoneArgs {
1150            title: "v1.1".to_string(),
1151            description: None,
1152            due_on: None,
1153        };
1154
1155        let ms = provider.edit(3, args).await.expect("should edit");
1156
1157        assert_eq!(ms.title, "v1.1");
1158    }
1159
1160    #[tokio::test]
1161    async fn test_should_close_milestone_without_output_json_and_refetch() {
1162        let runner = SequencedMockCommandRunner::from_results(&[
1163            (true, ""),
1164            (
1165                true,
1166                r#"[{"id":1,"iid":3,"title":"v1.0","description":null,"state":"closed","due_date":null,"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-01T00:00:00Z"}]"#,
1167            ),
1168        ]);
1169        let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner.clone());
1170
1171        let ms = provider.close(3).await.expect("should close");
1172
1173        assert_eq!(ms.number, 3);
1174        assert_eq!(ms.state, State::Closed);
1175        // glab 1.113 has no `milestone close`; closing is `milestone edit --state close`.
1176        assert_eq!(
1177            runner.recorded_calls()[0].1,
1178            vec![
1179                "milestone",
1180                "edit",
1181                "3",
1182                "--state",
1183                "close",
1184                "--project",
1185                "owner/repo"
1186            ]
1187            .into_iter()
1188            .map(String::from)
1189            .collect::<Vec<_>>()
1190        );
1191    }
1192
1193    #[tokio::test]
1194    async fn test_should_reopen_milestone_without_output_json_and_refetch() {
1195        let runner = SequencedMockCommandRunner::from_results(&[
1196            (true, ""),
1197            (
1198                true,
1199                r#"[{"id":1,"iid":3,"title":"v1.0","description":null,"state":"active","due_date":null,"created_at":"2026-01-01T00:00:00Z","updated_at":"2026-01-01T00:00:00Z"}]"#,
1200            ),
1201        ]);
1202        let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner.clone());
1203
1204        let ms = provider.reopen(3).await.expect("should reopen");
1205
1206        assert_eq!(ms.number, 3);
1207        assert_eq!(ms.state, State::Open);
1208        // glab 1.113 has no `milestone reopen`; reopening is `milestone edit --state activate`.
1209        assert_eq!(
1210            runner.recorded_calls()[0].1,
1211            vec![
1212                "milestone",
1213                "edit",
1214                "3",
1215                "--state",
1216                "activate",
1217                "--project",
1218                "owner/repo"
1219            ]
1220            .into_iter()
1221            .map(String::from)
1222            .collect::<Vec<_>>()
1223        );
1224    }
1225
1226    // --- MilestoneData deserialization tests ---
1227
1228    #[test]
1229    fn test_should_deserialize_milestone_api_response() {
1230        let json = br#"{
1231            "id": 1,
1232            "iid": 1,
1233            "title": "v1.0 Release",
1234            "description": "First stable release",
1235            "state": "active",
1236            "due_date": "2026-06-01",
1237            "created_at": "2026-01-01T00:00:00Z",
1238            "updated_at": "2026-01-01T00:00:00Z"
1239        }"#;
1240
1241        let api: MilestoneApiResponse =
1242            serde_json::from_slice(json).expect("valid MilestoneApiResponse");
1243        let data: MilestoneData = api.into();
1244
1245        assert_eq!(data.number, 1);
1246        assert_eq!(data.title, "v1.0 Release");
1247        assert_eq!(data.description, Some("First stable release".into()));
1248        assert_eq!(data.state, State::Open);
1249    }
1250
1251    #[test]
1252    fn test_should_deserialize_closed_milestone() {
1253        let json = br#"{
1254            "id": 2,
1255            "iid": 2,
1256            "title": "v0.9 Beta",
1257            "description": null,
1258            "state": "closed",
1259            "due_date": null,
1260            "created_at": "2026-01-01T00:00:00Z",
1261            "updated_at": "2026-06-01T00:00:00Z"
1262        }"#;
1263
1264        let api: MilestoneApiResponse =
1265            serde_json::from_slice(json).expect("valid MilestoneApiResponse");
1266        let data: MilestoneData = api.into();
1267        assert_eq!(data.state, State::Closed);
1268        assert!(data.description.is_none());
1269    }
1270
1271    #[test]
1272    fn test_should_deserialize_milestone_list() {
1273        let json = br#"[
1274            {"id": 1, "iid": 1, "title": "v1.0", "description": null, "state": "active", "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-01-01T00:00:00Z"},
1275            {"id": 2, "iid": 2, "title": "v0.9", "description": "Beta", "state": "closed", "created_at": "2026-01-01T00:00:00Z", "updated_at": "2026-06-01T00:00:00Z"}
1276        ]"#;
1277
1278        let milestones: Vec<MilestoneApiResponse> =
1279            serde_json::from_slice(json).expect("valid MilestoneApiResponse list");
1280        assert_eq!(milestones.len(), 2);
1281        assert_eq!(milestones[0].title, "v1.0");
1282        assert_eq!(milestones[1].title, "v0.9");
1283    }
1284
1285    // --- Pagination tests ---
1286
1287    #[tokio::test]
1288    async fn test_should_produce_complete_argv_for_gitlab_label_list_with_default_limit() {
1289        let runner = MockCommandRunner::success("[]");
1290        let provider = GitLabLabelProvider::with_runner("owner/repo", runner.clone());
1291
1292        let paged = provider.list(None).await.expect("should list");
1293
1294        assert!(paged.items.is_empty());
1295        assert_eq!(runner.recorded_calls()[0].0, "glab");
1296        assert_eq!(
1297            runner.recorded_calls()[0].1,
1298            vec![
1299                "label",
1300                "list",
1301                "--repo",
1302                "owner/repo",
1303                "--output",
1304                "json",
1305                "--per-page",
1306                "100",
1307                "--page",
1308                "1"
1309            ]
1310            .into_iter()
1311            .map(String::from)
1312            .collect::<Vec<_>>()
1313        );
1314    }
1315
1316    #[tokio::test]
1317    async fn test_should_produce_complete_argv_for_gitlab_milestone_list_with_default_limit() {
1318        let runner = MockCommandRunner::success("[]");
1319        let provider = GitLabMilestoneProvider::with_runner("owner/repo", runner.clone());
1320
1321        let paged = provider.list(None).await.expect("should list");
1322
1323        assert!(paged.items.is_empty());
1324        assert_eq!(runner.recorded_calls()[0].0, "glab");
1325        assert_eq!(
1326            runner.recorded_calls()[0].1,
1327            vec![
1328                "milestone",
1329                "list",
1330                "--project",
1331                "owner/repo",
1332                "--output",
1333                "json",
1334                "--per-page",
1335                "100",
1336                "--page",
1337                "1"
1338            ]
1339            .into_iter()
1340            .map(String::from)
1341            .collect::<Vec<_>>()
1342        );
1343    }
1344
1345    /// 回归测试(Issue #396):`glab milestone` 系列子命令用 `--project`,
1346    /// 该参数无论是否自建实例都只接受裸 `namespace/project`,绝不接受完整
1347    /// remote URL(这与 `--repo` 恰好相反)。`GitLabMilestoneProvider::new`
1348    /// 是 `handle_milestone` 现在唯一使用的构造方式——本测试确认它构造出的
1349    /// `--project` 参数值恒等于传入的裸 repo,即便该 repo 看起来像是来自
1350    /// 自建实例场景(用真实自建实例 `192.168.230.23` 的 `namespace/project`
1351    /// 形态举例,而不是完整 `git@192.168.230.23:...` URL)。
1352    #[tokio::test]
1353    async fn test_should_use_bare_repo_as_project_flag_never_full_remote_url() {
1354        let runner = MockCommandRunner::success("[]");
1355        let provider = GitLabMilestoneProvider::with_runner("iproost/iproost-docs", runner.clone());
1356
1357        provider.list(None).await.expect("should list");
1358
1359        let args = &runner.recorded_calls()[0].1;
1360        assert!(
1361            args.windows(2)
1362                .any(|w| w[0] == "--project" && w[1] == "iproost/iproost-docs"),
1363            "--project 必须是裸 namespace/project,实际参数: {args:?}"
1364        );
1365        assert!(
1366            !args.iter().any(|a| a.contains("://") || a.contains('@')),
1367            "--project 绝不能携带完整 remote URL,实际参数: {args:?}"
1368        );
1369    }
1370
1371    /// 验证名称→id 解析在被截断时报错而非静默使用不完整集合。
1372    ///
1373    /// 注:任务简报原文声称此截断防护应加在 `delete` 上("delete 需要
1374    /// 全量查找以按名解析 id"),但实际代码中 `delete` 直接
1375    /// `glab label delete <name>`,从不做 id 解析、也从不调用
1376    /// `list_api`/分页查询;真正做名称→id 解析的是 `edit`
1377    /// (见本文件 `edit` 方法)。因此本测试针对 `edit`,而非简报所述的
1378    /// `delete`。
1379    #[tokio::test]
1380    async fn test_should_error_when_label_edit_lookup_is_truncated() {
1381        let labels: Vec<String> = (0..1001)
1382            .map(|i| format!(r##"{{"id":{i},"name":"label-{i}","color":"#ffffff"}}"##))
1383            .collect();
1384        let json = format!("[{}]", labels.join(","));
1385        let runner = MockCommandRunner::success(&json);
1386        let provider = GitLabLabelProvider::with_runner("owner/repo", runner);
1387
1388        let args = CreateLabelArgs {
1389            name: "renamed".to_string(),
1390            color: "#ffffff".to_string(),
1391            description: None,
1392        };
1393
1394        let err = provider
1395            .edit("label-999", args)
1396            .await
1397            .expect_err("edit should fail when lookup is truncated");
1398        assert!(err.to_string().contains("truncated"));
1399    }
1400
1401    /// 验证写操作(`create`)成功后,若读回被截断,报告的是"截断"而非
1402    /// "未找到"——写操作本身已经成功,不能让用户误以为写入失败了。
1403    #[tokio::test]
1404    async fn test_should_report_truncation_not_missing_when_create_readback_is_truncated() {
1405        let labels: Vec<String> = (0..1001)
1406            .map(|i| format!(r##"{{"id":{i},"name":"label-{i}","color":"#ffffff"}}"##))
1407            .collect();
1408        let json = format!("[{}]", labels.join(","));
1409        // 同一份固定响应既充当 `label create` 的(被忽略的)输出,也充当
1410        // 紧接着 `list()` 读回的响应;mock 无视 page/per-page 参数,总是
1411        // 返回整个数组,因此读回一次即触发 N+1 探测下的截断。
1412        let runner = MockCommandRunner::success(&json);
1413        let provider = GitLabLabelProvider::with_runner("owner/repo", runner);
1414
1415        let args = CreateLabelArgs {
1416            name: "brand-new-label".to_string(),
1417            color: "#00ff00".to_string(),
1418            description: None,
1419        };
1420
1421        let err = provider.create(args).await.expect_err(
1422            "create should report truncated read-back rather than silently claiming success or \
1423             lying about not-found",
1424        );
1425        let msg = err.to_string();
1426        assert!(
1427            msg.contains("truncated"),
1428            "expected a truncation error, got: {msg}"
1429        );
1430        assert!(
1431            !msg.contains("not found after create"),
1432            "must not report the just-created label as missing when the read-back was merely \
1433             truncated: {msg}"
1434        );
1435    }
1436}