1use std::fmt::Write as _;
23use std::path::{Path, PathBuf};
24use std::time::Duration;
25
26use anyhow::{Context as _, Result, anyhow, bail};
27use serde::{Deserialize, Serialize};
28
29use crate::agent::{self, Invocation, SeatState};
30#[cfg(test)]
31use crate::ask;
32use crate::config::AgentSpec;
33use crate::git;
34use crate::land;
35use crate::notices::{Link, Notice, Notices};
36use crate::proc::Quiet as _;
37use crate::release_manifest;
38use crate::run::{self, RunState, RunStatus};
39use crate::verdict;
40
41#[derive(Debug, Clone, Serialize, Deserialize)]
43pub struct DecisionAttempt {
44 pub agent: String,
46 pub outcome: String,
48}
49
50async fn ask_decision(
53 state: &mut RunState,
54 repo: &Path,
55 prompt: &str,
56 timeout: Duration,
57) -> Result<(AgentSpec, SeatState, BumpDecision)> {
58 let chain = agent::pick_chain(
59 &state.config.agents,
60 state.config.roles.chatter.as_ref(),
61 &agent::installed,
62 "chatter (release-bump decision)",
63 )?;
64 let attempt_timeout = timeout / u32::try_from(chain.len()).unwrap_or(u32::MAX);
67 let artifacts = agent::artifacts_dir(&state.dir());
68 let cache = state.config.cache_dir();
69 let mut failures = Vec::new();
70 for (n, spec) in chain.iter().enumerate() {
71 let mut seat = crate::graph::handover_seat("bump", &spec.id, state.next_seat_seed());
72 let attempt = state.bump_decision_attempts.len() + 1;
75 let stem = format!("bump-decision-{attempt}");
76 state.event(
77 "bump",
78 format!("decision attempt {attempt}: trying {} ({stem})", spec.id),
79 );
80 let outcome = async {
82 let spec = agent::for_github_text(spec, &state.config.graph.github_language, repo)?;
83 agent::invoke(
84 &spec,
85 &mut seat,
86 &Invocation {
87 coordination: state.config.coordination.as_ref(),
88 fetched_base: None,
89 cwd: repo,
90 prompt,
91 timeout: attempt_timeout,
92 allow_write: false,
93 sessions: false,
94 artifacts: &artifacts,
95 stem: &stem,
96 run: &state.id,
97 node: "bump",
98 cache_dir: cache.as_deref(),
99 attachments: &[],
100 writable: &[],
101 },
102 )
103 .await
104 }
105 .await;
106 let parsed = if agent::chain_advances(&outcome) {
107 None
108 } else {
109 outcome
110 .as_ref()
111 .ok()
112 .and_then(|out| parse_decision(&out.text).ok())
113 };
114 let (class, reason) = match &outcome {
117 Ok(out) if out.quota_exhausted() => {
118 (run::FailClass::Quota, "rate/quota limit".to_owned())
119 }
120 Ok(out) if out.timed_out => (run::FailClass::Timeout, "timed out".to_owned()),
121 Ok(out) if out.exit_code != Some(0) => (
122 run::FailClass::Other("cli".into()),
123 format!(
124 "CLI failed ({})",
125 crate::notices::exit_status(out.exit_code)
126 ),
127 ),
128 Ok(out) if out.text.trim().is_empty() => (
129 run::FailClass::Other("empty".into()),
130 "empty output".to_owned(),
131 ),
132 Err(_) => (
133 run::FailClass::Other("cli".into()),
134 "CLI invocation failed; inspect attempt artifacts".to_owned(),
135 ),
136 _ => (
137 run::FailClass::Other("json".into()),
138 "invalid decision JSON or missing reason".to_owned(),
139 ),
140 };
141 let status = if parsed.is_some() {
142 "valid decision"
143 } else {
144 &reason
145 };
146 state.bump_decision_attempts.push(DecisionAttempt {
147 agent: spec.id.clone(),
148 outcome: status.to_owned(),
149 });
150 state.event(
151 "bump",
152 format!("decision attempt {attempt}: {}: {status}", spec.id),
153 );
154 if let Some(decision) = parsed {
155 return Ok((spec.clone(), seat, decision));
156 }
157 failures.push(format!("{}: {reason}", spec.id));
158 if let Some(next) = chain.get(n + 1) {
159 crate::graph::record_handover(
160 state, "bump", "bump", &spec.id, &next.id, &class, &reason,
161 );
162 }
163 }
164 bail!(
165 "release-bump decision exhausted {} eligible agent(s): {}. Check CLI subscription limits, availability and bump-decision attempt artifacts; adjust [roles] chatter or retry after recovery. No release PR was created by this decision",
166 chain.len(),
167 failures.join("; ")
168 )
169}
170
171async fn guard_reason(
174 state: &mut RunState,
175 repo: &Path,
176 prompt: &str,
177 spec: &AgentSpec,
178 seat: &mut SeatState,
179 decision: &mut BumpDecision,
180) {
181 let artifacts = agent::artifacts_dir(&state.dir());
182 let mut violations =
183 crate::github_text::check_for(&state.config.graph, "", &decision.reason, None);
184 violations.retain(|v| *v != crate::github_text::Violation::SensitiveData);
186 if violations.is_empty() {
187 decision.reason = crate::scrub::scrub(&decision.reason, &crate::scrub::Identity::current());
188 }
189 if state.config.graph.github_text_guard && !violations.is_empty() {
190 state.event(
191 "github-text",
192 format!("release reason rejected: {violations:?}; requesting one rewrite"),
193 );
194 let rewrite = format!(
195 "{prompt}\n\nYour release reason failed the GitHub text gate: {violations:?}. Return the same decision JSON with an English reason containing no local identity or secrets. Previous reason: {}",
196 decision.reason
197 );
198 let retry = async {
199 let spec = agent::for_github_text(spec, &state.config.graph.github_language, repo)?;
200 agent::invoke(
201 &spec,
202 seat,
203 &Invocation {
204 coordination: state.config.coordination.as_ref(),
205 fetched_base: None,
206 cwd: repo,
207 prompt: &rewrite,
208 timeout: crate::graph::retry_budget(DECISION_TIMEOUT, true),
209 allow_write: false,
210 sessions: false,
211 artifacts: &artifacts,
212 stem: "bump-rewrite",
213 run: &state.id,
214 node: "bump",
215 cache_dir: state.config.cache_dir().as_deref(),
216 attachments: &[],
217 writable: &[],
218 },
219 )
220 .await
221 }
222 .await;
223 let reason = retry
224 .ok()
225 .filter(|o| o.usable())
226 .and_then(|o| parse_decision(&o.text).ok())
227 .filter(|d| {
228 d.level == decision.level
229 && crate::github_text::check_for(&state.config.graph, "", &d.reason, None)
230 .is_empty()
231 })
232 .map(|d| d.reason);
233 if let Some(reason) = reason {
234 decision.reason = reason;
235 state.event("github-text", "release reason rewrite passed");
236 } else {
237 decision.reason = "The merged change requires a release.".to_owned();
238 state.event(
239 "github-text",
240 "release reason rewrite unavailable or rejected; using neutral text",
241 );
242 }
243 }
244}
245
246const DECISION_TIMEOUT: Duration = Duration::from_secs(600);
254
255pub fn should_release_bump(status: RunStatus) -> bool {
271 status == RunStatus::Merged
272}
273
274#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
276#[serde(rename_all = "lowercase")]
277pub enum BumpLevel {
278 Major,
280 Minor,
282 Patch,
284}
285
286impl BumpLevel {
287 pub fn as_str(self) -> &'static str {
289 match self {
290 Self::Major => "major",
291 Self::Minor => "minor",
292 Self::Patch => "patch",
293 }
294 }
295
296 fn severity(self) -> u8 {
301 match self {
302 Self::Patch => 0,
303 Self::Minor => 1,
304 Self::Major => 2,
305 }
306 }
307}
308
309#[derive(Debug, Clone, Deserialize)]
316pub struct BumpDecision {
317 pub level: BumpLevel,
319 pub reason: String,
322}
323
324pub fn parse_decision(text: &str) -> Result<BumpDecision> {
328 let decision: BumpDecision = verdict::extract_json(text)?;
329 if decision.reason.trim().is_empty() {
330 bail!("the bump decision carried no reason");
331 }
332 Ok(decision)
333}
334
335#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
338pub struct Version {
339 pub major: u64,
341 pub minor: u64,
343 pub patch: u64,
345}
346
347impl Version {
348 pub fn parse(s: &str) -> Result<Self> {
353 let s = s.trim();
354 let mut parts = s.splitn(3, '.');
355 let major = parts
356 .next()
357 .with_context(|| format!("`{s}` has no major component"))?;
358 let minor = parts
359 .next()
360 .with_context(|| format!("`{s}` has no minor component"))?;
361 let patch = parts
362 .next()
363 .with_context(|| format!("`{s}` has no patch component"))?;
364 let patch_digits: String = patch.chars().take_while(char::is_ascii_digit).collect();
365 Ok(Self {
366 major: major
367 .trim()
368 .parse()
369 .with_context(|| format!("`{major}` is not a number"))?,
370 minor: minor
371 .trim()
372 .parse()
373 .with_context(|| format!("`{minor}` is not a number"))?,
374 patch: patch_digits
375 .parse()
376 .with_context(|| format!("`{patch}` has no numeric patch component"))?,
377 })
378 }
379
380 #[must_use]
383 pub fn bump(self, level: BumpLevel) -> Self {
384 match level {
385 BumpLevel::Major => Self {
386 major: self.major + 1,
387 minor: 0,
388 patch: 0,
389 },
390 BumpLevel::Minor => Self {
391 major: self.major,
392 minor: self.minor + 1,
393 patch: 0,
394 },
395 BumpLevel::Patch => Self {
396 major: self.major,
397 minor: self.minor,
398 patch: self.patch + 1,
399 },
400 }
401 }
402}
403
404impl std::fmt::Display for Version {
405 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
406 write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
407 }
408}
409
410pub fn is_release_only(files: &[String]) -> bool {
419 !files.is_empty() && files.iter().all(|f| f == "Cargo.toml" || f == "Cargo.lock")
420}
421
422fn rewrite_table_version(toml: &str, table: &str, new_version: &str) -> Result<String> {
433 let mut out = String::with_capacity(toml.len() + 8);
434 let mut in_table = false;
435 let mut done = false;
436 for line in toml.split_inclusive('\n') {
437 let trimmed = line.trim();
438 if trimmed.starts_with('[') {
439 in_table = trimmed == table;
440 }
441 if !done && in_table && trimmed.split('=').next().map(str::trim) == Some("version") {
442 let newline = if line.ends_with("\r\n") { "\r\n" } else { "\n" };
443 let _ = write!(out, "version = \"{new_version}\"{newline}");
444 done = true;
445 continue;
446 }
447 out.push_str(line);
448 }
449 if !done {
450 bail!("no `version` field found under `{table}`");
451 }
452 Ok(out)
453}
454
455fn strip_trailing_comment(s: &str) -> &str {
461 let mut in_string = false;
462 let mut quote = '"';
463 for (i, c) in s.char_indices() {
464 if in_string {
465 if c == quote {
466 in_string = false;
467 }
468 } else if c == '"' || c == '\'' {
469 in_string = true;
470 quote = c;
471 } else if c == '#' {
472 return s[..i].trim_end();
473 }
474 }
475 s
476}
477
478fn unquote_key(key: &str) -> &str {
484 for quote in ['"', '\''] {
485 if let Some(inner) = key.strip_prefix(quote).and_then(|k| k.strip_suffix(quote)) {
486 return inner;
487 }
488 }
489 key
490}
491
492fn extract_workspace_dependencies_fragment(toml: &str) -> String {
504 let mut fragment = String::new();
505 let mut capturing = false;
506 for line in toml.split_inclusive('\n') {
507 let header = strip_trailing_comment(line.trim());
508 if header.starts_with('[') {
509 if header == "[workspace.dependencies]" {
510 capturing = true;
511 fragment.push_str("[dependencies]\n");
512 } else if let Some(name) = header
513 .strip_prefix("[workspace.dependencies.")
514 .and_then(|rest| rest.strip_suffix(']'))
515 {
516 capturing = true;
517 let _ = writeln!(fragment, "[dependencies.{name}]");
518 } else {
519 capturing = false;
520 }
521 continue;
522 }
523 if capturing {
524 fragment.push_str(line);
525 }
526 }
527 fragment
528}
529
530fn internal_pin_names(toml: &str) -> Result<Vec<String>> {
548 let fragment = extract_workspace_dependencies_fragment(toml);
549 if fragment.trim().is_empty() {
550 return Ok(Vec::new());
551 }
552 let value: toml::Value =
553 toml::from_str(&fragment).context("failed to parse `[workspace.dependencies]` as TOML")?;
554 let mut names: Vec<String> = value
555 .get("dependencies")
556 .and_then(|d| d.as_table())
557 .into_iter()
558 .flatten()
559 .filter(|(_, dep)| {
560 dep.as_table()
561 .is_some_and(|t| t.contains_key("path") && t.contains_key("version"))
562 })
563 .map(|(name, _)| name.clone())
564 .collect();
565 names.sort();
566 Ok(names)
567}
568
569fn rewrite_quoted_field(line: &str, key: &str, new_value: &str) -> Option<String> {
579 let is_ident = |c: char| c.is_ascii_alphanumeric() || c == '_' || c == '-';
580 let mut search_from = 0;
581 while let Some(rel) = line[search_from..].find(key) {
582 let key_start = search_from + rel;
583 let before_ok = key_start == 0 || !is_ident(line[..key_start].chars().next_back().unwrap());
584 let eq_pos = key_start
585 + key.len()
586 + (line[key_start + key.len()..].len()
587 - line[key_start + key.len()..].trim_start().len());
588 if before_ok && line[eq_pos..].starts_with('=') {
589 let after_eq = &line[eq_pos + 1..];
590 let ws_len = after_eq.len() - after_eq.trim_start().len();
591 let quote_pos = eq_pos + 1 + ws_len;
592 if let Some(quote_char) = line[quote_pos..]
593 .chars()
594 .next()
595 .filter(|c| *c == '"' || *c == '\'')
596 {
597 let value_begin = quote_pos + quote_char.len_utf8();
598 if let Some(end_rel) = line[value_begin..].find(quote_char) {
599 let value_end = value_begin + end_rel;
600 let mut out = String::with_capacity(line.len());
601 out.push_str(&line[..value_begin]);
602 out.push_str(new_value);
603 out.push_str(&line[value_end..]);
604 return Some(out);
605 }
606 }
607 }
608 search_from = key_start + key.len();
609 }
610 None
611}
612
613fn rewrite_workspace_dependency_pins(
628 toml: &str,
629 names: &[String],
630 new_version: &str,
631) -> Result<String> {
632 if names.is_empty() {
633 return Ok(toml.to_owned());
634 }
635 let mut out = String::with_capacity(toml.len() + names.len() * 8);
636 let mut in_flat_table = false;
637 let mut in_named_table: Option<String> = None;
638 let mut rewritten: std::collections::HashSet<String> = std::collections::HashSet::new();
639
640 for line in toml.split_inclusive('\n') {
641 let trimmed = line.trim();
642 if trimmed.starts_with('[') {
643 let header = strip_trailing_comment(trimmed);
644 in_flat_table = header == "[workspace.dependencies]";
645 in_named_table = header
646 .strip_prefix("[workspace.dependencies.")
647 .and_then(|rest| rest.strip_suffix(']'))
648 .map(str::to_owned);
649 out.push_str(line);
650 continue;
651 }
652
653 let key = trimmed.split('=').next().map(str::trim).map(unquote_key);
654
655 if in_flat_table {
656 if let Some(name) = key.and_then(|k| names.iter().find(|n| n.as_str() == k)) {
658 if let Some(rewritten_line) = rewrite_quoted_field(line, "version", new_version) {
659 rewritten.insert(name.clone());
660 out.push_str(&rewritten_line);
661 continue;
662 }
663 } else if let Some(name) = key.and_then(|k| {
664 k.strip_suffix(".version")
665 .and_then(|prefix| names.iter().find(|n| n.as_str() == prefix))
666 }) {
667 if let Some(rewritten_line) = rewrite_quoted_field(line, "version", new_version) {
672 rewritten.insert(name.clone());
673 out.push_str(&rewritten_line);
674 continue;
675 }
676 }
677 } else if let Some(table_name) = &in_named_table {
678 if key == Some("version") && names.iter().any(|n| n == table_name) {
679 if let Some(rewritten_line) = rewrite_quoted_field(line, "version", new_version) {
680 rewritten.insert(table_name.clone());
681 out.push_str(&rewritten_line);
682 continue;
683 }
684 }
685 }
686
687 out.push_str(line);
688 }
689
690 for name in names {
691 if !rewritten.contains(name) {
692 bail!(
693 "could not rewrite the `[workspace.dependencies]` version pin \
694 for `{name}` - its `version` field was not found in a shape \
695 this rewrite understands"
696 );
697 }
698 }
699 Ok(out)
700}
701
702fn verify_pins_rewritten(toml: &str, names: &[String], new_version: &str) -> Result<()> {
710 let fragment = extract_workspace_dependencies_fragment(toml);
711 let value: toml::Value = toml::from_str(&fragment)
712 .context("rewritten `[workspace.dependencies]` failed to parse")?;
713 let deps = value.get("dependencies").and_then(|d| d.as_table());
714 for name in names {
715 let actual = deps
716 .and_then(|d| d.get(name))
717 .and_then(|dep| dep.as_table())
718 .and_then(|t| t.get("version"))
719 .and_then(|v| v.as_str());
720 if actual != Some(new_version) {
721 bail!(
722 "the `[workspace.dependencies]` version pin for `{name}` did \
723 not end up at `{new_version}` after the rewrite"
724 );
725 }
726 }
727 Ok(())
728}
729
730pub fn rewrite_cargo_version(toml: &str, new_version: &str) -> Result<String> {
752 let rewritten = rewrite_table_version(toml, "[package]", new_version)
753 .or_else(|_| rewrite_table_version(toml, "[workspace.package]", new_version))
754 .context("no `version` field found under `[package]` or `[workspace.package]`")?;
755
756 let pin_names = internal_pin_names(&rewritten)?;
757 if pin_names.is_empty() {
758 return Ok(rewritten);
759 }
760
761 let rewritten = rewrite_workspace_dependency_pins(&rewritten, &pin_names, new_version)?;
762 verify_pins_rewritten(&rewritten, &pin_names, new_version)?;
763 Ok(rewritten)
764}
765
766fn version_in_table(toml: &str, table: &str) -> Option<String> {
768 let mut in_table = false;
769 for line in toml.lines() {
770 let trimmed = line.trim();
771 if trimmed.starts_with('[') {
772 in_table = trimmed == table;
773 continue;
774 }
775 if !in_table {
776 continue;
777 }
778 let mut parts = trimmed.splitn(2, '=');
779 let key = parts.next().map(str::trim);
780 let Some(value) = parts.next() else {
781 continue;
782 };
783 if key == Some("version") {
784 return Some(value.trim().trim_matches('"').to_owned());
785 }
786 }
787 None
788}
789
790pub(crate) fn current_version(toml: &str) -> Result<String> {
795 version_in_table(toml, "[package]")
796 .or_else(|| version_in_table(toml, "[workspace.package]"))
797 .context("no `version` field found under `[package]` or `[workspace.package]`")
798}
799
800async fn branch_version(repo: &Path, remote: &str, branch: &str, primary: &str) -> Option<String> {
804 let from_name = branch.strip_prefix("chore/release-v").map(str::to_owned);
805 let tracking = format!("refs/remotes/{remote}/{branch}");
808 let spec = format!("+refs/heads/{branch}:{tracking}");
809 let fetched = git::git_raw(repo, &["fetch", "--quiet", remote, &spec]).await;
810 if fetched.is_ok_and(|o| o.code == Some(0))
811 && let Ok(out) = git::git_raw(repo, &["show", &format!("{tracking}:{primary}")]).await
812 && out.code == Some(0)
813 && let Ok(v) = current_version(&out.stdout)
814 {
815 return Some(v);
816 }
817 from_name
818}
819
820pub fn decision_prompt(
830 subject: &str,
831 instruction: &str,
832 diffstat: &str,
833 files: &[String],
834 current_version: &str,
835) -> String {
836 let mut s = format!(
837 "A pull request just merged into the base branch. Decide which digit \
838 of this project's `major.minor.patch` version this change earns, so \
839 a release bump can be opened for exactly it.\n\n\
840 Current version: {current_version}\n\n\
841 # Merge subject\n\n{subject}\n\n\
842 # The task that produced it\n\n{instruction}\n\n\
843 # Files changed ({} total)\n\n",
844 files.len()
845 );
846 const MAX_FILES: usize = 50;
847 for f in files.iter().take(MAX_FILES) {
848 let _ = writeln!(s, "- {f}");
849 }
850 if files.len() > MAX_FILES {
851 let _ = writeln!(s, "- ... and {} more", files.len() - MAX_FILES);
852 }
853 let _ = write!(s, "\n# Diffstat\n\n```\n{}\n```\n", diffstat.trim());
854
855 s.push_str(
856 "\n# How to decide\n\n\
857 This project is below version `1.0.0`. At that stage **`minor` is \
858 the digit that carries a breaking change** - do not spend `major` \
859 below `1.0.0`.\n\n\
860 A change is breaking, and earns `minor`, when it changes any of: \
861 the public API reachable from `src/lib.rs`, a CLI subcommand or \
862 flag, an HTTP API route or response shape, a configuration key, or \
863 the on-disk shape of persisted state.\n\n\
864 A user-visible new capability that breaks none of the above also \
865 earns `minor`.\n\n\
866 A fix, an internal refactor, or a dependency update earns `patch`.\n\n\
867 **When it is not obvious which digit applies, choose the larger \
868 one.** An oversized bump costs nothing; a breaking change shipped as \
869 `patch` breaks every downstream update that pins a range.\n\n\
870 # Output\n\n\
871 Reply with exactly one fenced JSON object and nothing that matters \
872 outside it:\n\n\
873 ```json\n\
874 {\"level\": \"major\" | \"minor\" | \"patch\", \"reason\": \"one line\"}\n\
875 ```\n",
876 );
877 let _ = write!(
879 s,
880 "\n{}\n\nThe `reason` goes into a GitHub pull request body, so write it \
881 in English.\n",
882 crate::prompt::GITHUB_ENGLISH_HEADING
883 );
884 s
885}
886
887#[derive(Debug, Clone, Serialize, Deserialize)]
903pub struct PendingBump {
904 pub target_version: String,
906 pub level: BumpLevel,
909 pub branch: String,
912 pub pr_url: String,
915}
916
917pub fn marker_path(home: &Path, repo: &Path) -> PathBuf {
921 let key = repo.to_string_lossy();
922 home.join("bump")
923 .join(format!("{:016x}.json", crate::rng::fnv1a(&key)))
924}
925
926pub fn read_marker(path: &Path) -> Option<PendingBump> {
930 let body = std::fs::read_to_string(path).ok()?;
931 serde_json::from_str(&body).ok()
932}
933
934pub fn write_marker(path: &Path, marker: &PendingBump) -> Result<()> {
938 if let Some(parent) = path.parent() {
939 std::fs::create_dir_all(parent).with_context(|| format!("create {}", parent.display()))?;
940 }
941 let body = serde_json::to_string_pretty(marker).context("serialize pending bump")?;
942 let tmp = path.with_extension("json.tmp");
943 std::fs::write(&tmp, &body).with_context(|| format!("write {}", tmp.display()))?;
944 std::fs::rename(&tmp, path).with_context(|| format!("replace {}", path.display()))?;
945 Ok(())
946}
947
948pub fn clear_marker(path: &Path) {
951 let _ = std::fs::remove_file(path);
952}
953
954#[derive(Debug, Clone, PartialEq, Eq)]
958pub enum Coalesce {
959 Proceed,
962 Skip {
964 target_version: String,
966 },
967}
968
969pub fn coalesce(pending: Option<&PendingBump>, current_version: &str) -> Result<Coalesce> {
971 let Some(pending) = pending else {
972 return Ok(Coalesce::Proceed);
973 };
974 let current = Version::parse(current_version)?;
975 let target = Version::parse(&pending.target_version)?;
976 if current >= target {
977 return Ok(Coalesce::Proceed);
978 }
979 Ok(Coalesce::Skip {
980 target_version: pending.target_version.clone(),
981 })
982}
983
984#[derive(Debug, Clone, Copy, PartialEq, Eq)]
986pub enum PendingAction {
987 AlreadyCovered,
990 Escalate,
993}
994
995pub fn pending_action(pending_level: BumpLevel, decision_level: BumpLevel) -> PendingAction {
1004 if decision_level.severity() > pending_level.severity() {
1005 PendingAction::Escalate
1006 } else {
1007 PendingAction::AlreadyCovered
1008 }
1009}
1010
1011fn parse_pr_state(json: &str) -> Result<bool> {
1013 #[derive(Deserialize)]
1014 struct State {
1015 state: String,
1016 }
1017 let parsed: State =
1018 serde_json::from_str(json).context("parse `gh pr view --json state` output")?;
1019 Ok(parsed.state.eq_ignore_ascii_case("OPEN"))
1020}
1021
1022async fn pr_is_open(repo: &Path, pr_url: &str) -> Result<bool> {
1035 let out = tokio::process::Command::new("gh")
1036 .args(["pr", "view", pr_url, "--json", "state"])
1037 .current_dir(repo)
1038 .quiet()
1039 .stdin(std::process::Stdio::null())
1040 .output()
1041 .await
1042 .context("spawn gh pr view")?;
1043 if !out.status.success() {
1044 bail!(
1045 "gh pr view {pr_url}: {}",
1046 String::from_utf8_lossy(&out.stderr).trim()
1047 );
1048 }
1049 parse_pr_state(&String::from_utf8_lossy(&out.stdout))
1050}
1051
1052const LOCK_STALE_AFTER: Duration = Duration::from_secs(30 * 60);
1060
1061struct MarkerLock {
1073 path: PathBuf,
1074}
1075
1076impl MarkerLock {
1077 #[cfg(test)]
1081 fn acquire(marker: &Path) -> Result<Option<Self>> {
1082 Self::acquire_with(marker, crate::lock_file::Retry::new(None))
1083 }
1084
1085 fn acquire_with(marker: &Path, retry: crate::lock_file::Retry) -> Result<Option<Self>> {
1086 let path = marker.with_extension("lock");
1087 if let Some(parent) = path.parent() {
1088 std::fs::create_dir_all(parent)
1089 .with_context(|| format!("create {}", parent.display()))?;
1090 }
1091 if Self::try_create(&path, retry)? {
1092 return Ok(Some(Self { path }));
1093 }
1094 if Self::is_stale(&path) {
1095 let _ = std::fs::remove_file(&path);
1096 if Self::try_create(&path, retry)? {
1097 return Ok(Some(Self { path }));
1098 }
1099 }
1100 Ok(None)
1101 }
1102
1103 fn try_create(path: &Path, retry: crate::lock_file::Retry) -> Result<bool> {
1104 match retry.create(path) {
1105 Ok(_) => Ok(true),
1106 Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => Ok(false),
1107 Err(e) => Err(e).with_context(|| format!("create {}", path.display())),
1108 }
1109 }
1110
1111 fn is_stale(path: &Path) -> bool {
1112 std::fs::metadata(path)
1113 .and_then(|m| m.modified())
1114 .ok()
1115 .and_then(|m| m.elapsed().ok())
1116 .is_some_and(|age| age >= LOCK_STALE_AFTER)
1117 }
1118}
1119
1120impl Drop for MarkerLock {
1121 fn drop(&mut self) {
1122 let _ = std::fs::remove_file(&self.path);
1123 }
1124}
1125
1126const LOCK_POLL: Duration = Duration::from_secs(5);
1128
1129const LOCK_WAIT_CEILING: Duration = Duration::from_secs(25 * 60);
1142
1143async fn wait_for_marker_lock(marker: &Path) -> Result<Option<MarkerLock>> {
1146 wait_for_marker_lock_with(marker, LOCK_POLL, LOCK_WAIT_CEILING).await
1147}
1148
1149async fn wait_for_marker_lock_with(
1153 marker: &Path,
1154 poll: Duration,
1155 ceiling: Duration,
1156) -> Result<Option<MarkerLock>> {
1157 let deadline = std::time::Instant::now() + ceiling;
1158 let retry = crate::lock_file::Retry::new(Some(deadline));
1159 loop {
1160 let marker = marker.to_owned();
1162 let acquired =
1163 tokio::task::spawn_blocking(move || MarkerLock::acquire_with(&marker, retry))
1164 .await
1165 .context("join marker lock acquisition")??;
1166 if let Some(lock) = acquired {
1167 return Ok(Some(lock));
1168 }
1169 let remaining = deadline.saturating_duration_since(std::time::Instant::now());
1170 if remaining.is_zero() {
1171 return Ok(None);
1172 }
1173 tokio::time::sleep(poll.min(remaining)).await;
1174 }
1175}
1176
1177fn level_between(from: Version, to: Version) -> Option<BumpLevel> {
1185 if to.major != from.major {
1186 Some(BumpLevel::Major)
1187 } else if to.minor != from.minor {
1188 Some(BumpLevel::Minor)
1189 } else if to.patch != from.patch {
1190 Some(BumpLevel::Patch)
1191 } else {
1192 None
1193 }
1194}
1195
1196fn parse_open_release_pr(json: &str) -> Result<Option<(String, String)>> {
1199 #[derive(Deserialize)]
1200 struct Pr {
1201 url: String,
1202 #[serde(rename = "headRefName")]
1203 head_ref_name: String,
1204 }
1205 let list: Vec<Pr> =
1206 serde_json::from_str(json).context("parse `gh pr list --json url,headRefName` output")?;
1207 Ok(list
1208 .into_iter()
1209 .find(|p| p.head_ref_name.starts_with("chore/release-v"))
1210 .map(|p| (p.head_ref_name, p.url)))
1211}
1212
1213pub(crate) fn parse_open_release_prs(json: &str) -> Result<Vec<(String, String)>> {
1216 #[derive(Deserialize)]
1217 struct Pr {
1218 url: String,
1219 #[serde(rename = "headRefName")]
1220 head_ref_name: String,
1221 }
1222 let list: Vec<Pr> =
1223 serde_json::from_str(json).context("parse `gh pr list --json url,headRefName` output")?;
1224 Ok(list
1225 .into_iter()
1226 .filter(|p| p.head_ref_name.starts_with("chore/release-v"))
1227 .map(|p| (p.head_ref_name, p.url))
1228 .collect())
1229}
1230
1231pub(crate) async fn list_open_release_prs(repo: &Path) -> Result<Vec<(String, String)>> {
1233 let out = tokio::process::Command::new("gh")
1234 .args([
1235 "pr",
1236 "list",
1237 "--state",
1238 "open",
1239 "--limit",
1240 "100",
1241 "--json",
1242 "url,headRefName",
1243 ])
1244 .current_dir(repo)
1245 .env_remove("GH_REPO")
1246 .quiet()
1247 .stdin(std::process::Stdio::null())
1248 .output()
1249 .await
1250 .context("spawn gh pr list")?;
1251 if !out.status.success() {
1252 bail!(
1253 "gh pr list: {}",
1254 String::from_utf8_lossy(&out.stderr).trim()
1255 );
1256 }
1257 parse_open_release_prs(&String::from_utf8_lossy(&out.stdout))
1258}
1259
1260async fn find_open_release_pr(repo: &Path) -> Result<Option<(String, String)>> {
1275 let out = tokio::process::Command::new("gh")
1276 .args(["pr", "list", "--state", "open", "--json", "url,headRefName"])
1277 .current_dir(repo)
1278 .quiet()
1279 .stdin(std::process::Stdio::null())
1280 .output()
1281 .await
1282 .context("spawn gh pr list")?;
1283 if !out.status.success() {
1284 bail!(
1285 "gh pr list: {}",
1286 String::from_utf8_lossy(&out.stderr).trim()
1287 );
1288 }
1289 parse_open_release_pr(&String::from_utf8_lossy(&out.stdout))
1290}
1291
1292pub async fn after_merge(state: &mut RunState, pr_url: &str) -> Result<()> {
1312 after_merge_at(state, pr_url, None, None).await
1313}
1314
1315#[derive(Debug, Default)]
1317struct Progress {
1318 version: Option<String>,
1320 pending_pr: Option<String>,
1322 skip: Option<Skip>,
1324}
1325
1326#[derive(Debug)]
1329struct Skip {
1330 reason: String,
1332 action: Option<String>,
1335}
1336
1337fn record_skip(state: &mut RunState, store: Option<&Notices>, skip: &Skip) {
1339 let record = state.release_bump.get_or_insert_with(Default::default);
1340 record.skipped = Some(skip.reason.clone());
1341 let Some(action) = &skip.action else {
1342 return;
1343 };
1344 record.action_required = Some(action.clone());
1345 let notice = Notice::error(
1346 &format!("release-bump:{}", state.id),
1347 format!(
1348 "Run {} merged, but its release bump was skipped: {action}.",
1349 state.id
1350 ),
1351 )
1352 .link(Link::Run {
1353 id: state.id.clone(),
1354 });
1355 let store = store.cloned().unwrap_or_else(Notices::open);
1356 if let Err(e) = store.raise_with(notice, &state.config.notify) {
1357 state.event("bump", format!("could not raise a notice: {e:#}"));
1358 }
1359 state.event("bump", format!("needs attention: {action}"));
1360}
1361
1362fn notice_for_failure(progress: &Progress, err: &anyhow::Error) -> (Option<String>, String) {
1368 (progress.version.clone(), format!("{err:#}"))
1369}
1370
1371fn failure_headline(reason: &str) -> Option<&str> {
1373 let lines = || {
1374 reason
1375 .lines()
1376 .map(str::trim)
1377 .filter(|line| !line.is_empty())
1378 };
1379 lines()
1380 .find(|line| line.starts_with("fatal:") || line.starts_with("error:"))
1381 .or_else(|| lines().next())
1382}
1383
1384#[cfg(test)]
1390async fn base_has_cargo_toml(repo: &Path, remote: &str, base: &str) -> Result<bool> {
1391 base_has_file(repo, remote, base, release_manifest::DEFAULT_PRIMARY).await
1392}
1393
1394async fn base_has_file(repo: &Path, remote: &str, base: &str, path: &str) -> Result<bool> {
1396 let out = git::git(
1397 repo,
1398 &[
1399 "ls-tree",
1400 "--name-only",
1401 &format!("{remote}/{base}"),
1402 "--",
1403 path,
1404 ],
1405 )
1406 .await
1407 .with_context(|| format!("look for {path} on the base branch"))?;
1408 Ok(!out.trim().is_empty())
1409}
1410
1411async fn change_base(dir: &Path, remote: &str, base: &str, branch: &str) -> Option<String> {
1415 let tip = git::rev_parse(dir, branch).await.ok()?;
1416 let mb = git::git(dir, &["merge-base", &format!("{remote}/{base}"), branch])
1417 .await
1418 .ok()?;
1419 let mb = mb.trim().to_owned();
1420 (!mb.is_empty() && mb != tip).then_some(mb)
1421}
1422
1423async fn primary_version_at(dir: &Path, rev: &str, path: &str) -> Option<String> {
1426 let out = git::git_raw(dir, &["show", &format!("{rev}:{path}")])
1427 .await
1428 .ok()?;
1429 if out.code != Some(0) {
1430 return None;
1431 }
1432 current_version(&out.stdout).ok()
1433}
1434
1435async fn after_merge_at(
1439 state: &mut RunState,
1440 pr_url: &str,
1441 home: Option<&Path>,
1442 store: Option<&Notices>,
1443) -> Result<()> {
1444 let mut progress = Progress::default();
1445 let result = after_merge_inner(state, pr_url, home, &mut progress).await;
1446 if let Some(skip) = &progress.skip {
1447 record_skip(state, store, skip);
1448 }
1449 if let Err(e) = &result {
1450 let (version, reason) = notice_for_failure(&progress, e);
1451 let pending = progress.pending_pr.as_deref();
1452 let store = store.cloned().unwrap_or_else(Notices::open);
1453 report_problem_in(
1454 state,
1455 &store,
1456 pending,
1457 version.as_deref(),
1458 &reason,
1459 pending.is_some(),
1460 )
1461 .await;
1462 }
1463 result
1464}
1465
1466async fn after_merge_inner(
1467 state: &mut RunState,
1468 pr_url: &str,
1469 home: Option<&Path>,
1470 progress: &mut Progress,
1471) -> Result<()> {
1472 if !state.config.merge.release_bump {
1473 return Ok(());
1474 }
1475 let Some(winner) = state.winner().cloned() else {
1476 return Ok(());
1477 };
1478 let repo = state.repo.clone();
1479 let base = state.base_branch.clone();
1480 let remote = state.config.merge.remote.clone();
1481
1482 let files = git::changed_files(&winner.worktree, &base, &winner.branch)
1483 .await
1484 .unwrap_or_default();
1485 let declared = state.config.release.version_files.clone();
1486 let custom = release_manifest::is_custom(&declared);
1487 let primary = release_manifest::primary_path(&declared).to_owned();
1488 if release_manifest::release_only(&files, &declared) {
1489 let mb = change_base(&winner.worktree, &remote, &base, &winner.branch).await;
1493 let unchanged = custom
1494 && match mb {
1495 Some(mb) => matches!(
1496 (
1497 primary_version_at(&winner.worktree, &mb, &primary).await,
1498 primary_version_at(&winner.worktree, &winner.branch, &primary).await,
1499 ),
1500 (Some(before), Some(after)) if before == after
1501 ),
1502 None => false,
1503 };
1504 if !unchanged {
1505 state.event(
1506 "bump",
1507 "the merged change touches only the release manifest; not treating it as a trigger",
1508 );
1509 progress.skip = Some(Skip {
1510 reason: "the merged change touches only the release files; not a trigger"
1511 .to_owned(),
1512 action: None,
1513 });
1514 return Ok(());
1515 }
1516 }
1517
1518 git::fetch(&repo, &remote, &base).await.ok();
1521 if !base_has_file(&repo, &remote, &base, &primary).await? {
1522 state.event(
1523 "bump",
1524 if custom {
1525 format!(
1526 "release bump: no {primary} on the base branch (from [release] version_files); skipping"
1527 )
1528 } else {
1529 "release bump: no Cargo.toml on the base branch; release bumps are Rust-only, skipping"
1530 .to_owned()
1531 },
1532 );
1533 let releases_by_workflow =
1536 base_has_file(&repo, &remote, &base, ".github/workflows/auto-tag.yml")
1537 .await
1538 .unwrap_or(false);
1539 let ja = crate::lang::is_japanese(&state.config.graph.language);
1540 let action = releases_by_workflow.then(|| {
1541 if ja {
1542 format!(
1543 "base ブランチに {primary} がありません。auto-tag.yml があるリポジトリです。magi.toml の [release] version_files に版の正本 (auto-tag.yml が読む Cargo.toml) を指定するか、リリースを手で行ってください"
1544 )
1545 } else {
1546 format!(
1547 "the base branch has no {primary} but does have .github/workflows/auto-tag.yml; set [release] version_files in magi.toml to the version of record auto-tag.yml reads, or release by hand"
1548 )
1549 }
1550 });
1551 progress.skip = Some(Skip {
1552 reason: format!("no {primary} on the base branch; no release bump was made"),
1553 action,
1554 });
1555 return Ok(());
1556 }
1557
1558 let marker = marker_path(&home.map_or_else(run::home, Path::to_path_buf), &repo);
1559 let Some(_lock) = wait_for_marker_lock(&marker).await? else {
1566 state.event(
1567 "bump",
1568 "another release bump decision held the lock past the wait ceiling; skipping this round",
1569 );
1570 return Ok(());
1571 };
1572
1573 git::fetch(&repo, &remote, &base).await.ok();
1574 let mut versions = Vec::new();
1575 for f in release_manifest::effective(&declared) {
1576 let text = git::git(&repo, &["show", &format!("{remote}/{base}:{}", f.path)])
1577 .await
1578 .with_context(|| format!("read {} from the base branch", f.path))?;
1579 let v = release_manifest::read_version(f.kind, &text)
1580 .with_context(|| format!("read the version of {}", f.path))?;
1581 versions.push((f.path, v));
1582 }
1583 let base_version = match release_manifest::agree(&versions) {
1584 Ok(v) => v,
1585 Err(e) => {
1586 let reason = format!("{e:#}");
1587 state.event("bump", format!("release bump skipped: {reason}"));
1588 progress.skip = Some(Skip {
1589 action: Some(format!("{reason}; align them by hand, then release")),
1590 reason,
1591 });
1592 return Ok(());
1593 }
1594 };
1595 if custom && !state.config.release.is_local() {
1598 let mb = change_base(&winner.worktree, &remote, &base, &winner.branch)
1604 .await
1605 .unwrap_or_default();
1606 if !mb.is_empty()
1607 && let (Some(before), Some(after)) = (
1608 primary_version_at(&winner.worktree, &mb, &primary).await,
1609 primary_version_at(&winner.worktree, &winner.branch, &primary).await,
1610 )
1611 && before != after
1612 {
1613 state.event(
1614 "bump",
1615 format!(
1616 "the merged change already moved {primary} from v{before} to v{after}; leaving the release to the repository's auto-tag"
1617 ),
1618 );
1619 progress.skip = Some(Skip {
1620 reason: format!(
1621 "the change itself raised {primary} from v{before} to v{after}; the repository's auto-tag releases it"
1622 ),
1623 action: None,
1624 });
1625 return Ok(());
1626 }
1627 }
1628
1629 let mut pending = read_marker(&marker);
1630 if let Some(p) = &pending {
1631 match coalesce(Some(p), &base_version)? {
1632 Coalesce::Proceed => {
1633 clear_marker(&marker);
1636 pending = None;
1637 }
1638 Coalesce::Skip { target_version } => {
1639 if !pr_is_open(&repo, &p.pr_url).await.unwrap_or(true) {
1640 state.event(
1641 "bump",
1642 format!(
1643 "the pending release bump to v{target_version} ({}) is no longer \
1644 open; treating it as abandoned",
1645 p.pr_url
1646 ),
1647 );
1648 clear_marker(&marker);
1649 pending = None;
1650 }
1651 }
1656 }
1657 }
1658
1659 if pending.is_none() {
1660 if let Ok(Some((branch, url))) = find_open_release_pr(&repo).await
1665 && let Some(target) = branch_version(&repo, &remote, &branch, &primary)
1666 .await
1667 .and_then(|v| Version::parse(&v).ok())
1668 {
1669 let base_parsed = Version::parse(&base_version)?;
1670 if target > base_parsed
1671 && let Some(level) = level_between(base_parsed, target)
1672 {
1673 let adopted = PendingBump {
1674 target_version: target.to_string(),
1675 level,
1676 branch,
1677 pr_url: url,
1678 };
1679 let _ = write_marker(&marker, &adopted);
1682 pending = Some(adopted);
1683 }
1684 }
1685 }
1686
1687 progress.pending_pr = pending.as_ref().map(|p| p.pr_url.clone());
1688 let title = pr_title(&repo, pr_url).await.unwrap_or_default();
1689 let subject = land::merge_subject(
1690 crate::graph::landing_title(state, &title),
1691 &crate::graph::landing_subject_source(state),
1692 );
1693 let stat = git::diff_stat(&winner.worktree, &base, &winner.branch)
1694 .await
1695 .unwrap_or_default();
1696 let prompt = decision_prompt(&subject, &state.instruction, &stat, &files, &base_version);
1697
1698 let (spec, mut seat, mut decision) =
1699 ask_decision(state, &repo, &prompt, DECISION_TIMEOUT).await?;
1700 guard_reason(state, &repo, &prompt, &spec, &mut seat, &mut decision).await;
1701
1702 if let Some(p) = pending {
1703 return match pending_action(p.level, decision.level) {
1704 PendingAction::AlreadyCovered => {
1705 state.event(
1706 "bump",
1707 format!(
1708 "a release bump to v{} ({}) already covers at least a {} change; not \
1709 opening another",
1710 p.target_version,
1711 p.pr_url,
1712 decision.level.as_str()
1713 ),
1714 );
1715 Ok(())
1716 }
1717 PendingAction::Escalate => {
1718 progress.version = Some(
1719 Version::parse(&base_version)?
1720 .bump(decision.level)
1721 .to_string(),
1722 );
1723 escalate_pending(state, &repo, &remote, &p, &decision, &base_version, &marker).await
1724 }
1725 };
1726 }
1727
1728 let next = Version::parse(&base_version)?
1729 .bump(decision.level)
1730 .to_string();
1731 progress.version = Some(next.clone());
1732 let branch = format!("chore/release-v{next}");
1733 let worktree = state.dir().join("bump");
1734 let (shared, branch_ref, next_ref, decision_ref) = (&mut *state, &branch, &next, &decision);
1735 let (pr_url_opened, outcome) =
1736 release_attempt(
1737 &repo,
1738 &remote,
1739 &base,
1740 &worktree,
1741 &branch,
1742 |head| {
1743 let repo = repo.clone();
1744 async move { gh_open_pr_for_head(&repo, &head).await }
1745 },
1746 |wt| async move {
1747 open_bump_pr(shared, &wt, branch_ref, next_ref, decision_ref, pr_url).await
1748 },
1749 )
1750 .await?;
1751 let local = outcome == AutomergeOutcome::LocalGate;
1752 let (automerge_warning, merged_detail) = match outcome {
1753 AutomergeOutcome::Enabled | AutomergeOutcome::LocalGate => (None, None),
1754 AutomergeOutcome::MergedDirectly { detail } => (None, Some(detail)),
1755 AutomergeOutcome::Failed { reason } => (Some(reason), None),
1756 };
1757
1758 let marker_write = write_marker(
1767 &marker,
1768 &PendingBump {
1769 target_version: next.clone(),
1770 level: decision.level,
1771 branch,
1772 pr_url: pr_url_opened.clone(),
1773 },
1774 );
1775 state.event(
1776 "bump",
1777 format!(
1778 "opened a {} release bump to v{next} ({}): {pr_url_opened}",
1779 decision.level.as_str(),
1780 decision.reason
1781 ),
1782 );
1783 if let Err(e) = marker_write {
1784 state.event(
1785 "bump",
1786 format!(
1787 "could not record the pending release bump marker for v{next}: {e:#}; a later \
1788 merge may open a duplicate pull request if it cannot find {pr_url_opened} on \
1789 the forge either"
1790 ),
1791 );
1792 }
1793 state.release_bump = Some(run::ReleaseBump {
1794 pr_url: Some(pr_url_opened.clone()),
1795 version: Some(next.clone()),
1796 automerge_enabled: automerge_warning.is_none() && merged_detail.is_none() && !local,
1797 merged_directly: merged_detail.is_some(),
1798 local,
1799 ..run::ReleaseBump::default()
1800 });
1801 if let Some(detail) = merged_detail {
1802 clear_marker(&marker);
1805 state.event("bump", format!("merged v{next} directly: {detail}"));
1806 }
1807 if let Some(warning) = automerge_warning {
1808 state.event(
1809 "bump",
1810 format!("could not enable automerge on {pr_url_opened}: {warning}; merge it by hand"),
1811 );
1812 report_problem(state, Some(&pr_url_opened), Some(&next), &warning).await;
1813 }
1814 Ok(())
1815}
1816
1817pub const NOTICE_NODE: &str = "release-bump";
1822
1823fn automerge_hint(reason: &str) -> &'static str {
1830 let r = reason.to_lowercase();
1831 if is_clean_status_refusal(reason) {
1832 "merge the release pull request by hand; CI is already green"
1833 } else if r.contains("enablepullrequestautomerge") || r.contains("protected branch rules") {
1834 "merge the release pull request by hand, and enable branch protection with required \
1835 status checks on the base branch so automerge can work next time"
1836 } else {
1837 "merge the release pull request by hand"
1838 }
1839}
1840
1841fn automerge_failure_comment(reason: &str) -> String {
1843 format!(
1844 "magi could not enable automerge on this pull request: {reason}\n\n\
1845 Action required: {}. Until then the release does not happen.",
1846 automerge_hint(reason)
1847 )
1848}
1849
1850#[cfg(test)]
1858fn surface_problem(
1859 state: &mut RunState,
1860 store: &Notices,
1861 pr_url: Option<&str>,
1862 version: Option<&str>,
1863 reason: &str,
1864) -> Result<(Notice, Option<String>)> {
1865 surface_problem_in(state, store, pr_url, version, reason, false)
1866}
1867
1868fn surface_problem_in(
1872 state: &mut RunState,
1873 store: &Notices,
1874 pr_url: Option<&str>,
1875 version: Option<&str>,
1876 reason: &str,
1877 pending: bool,
1878) -> Result<(Notice, Option<String>)> {
1879 let reason = crate::scrub::scrub(reason, &crate::scrub::Identity::current());
1880 let reason = reason.as_str();
1881 let action = if let (true, Some(url)) = (pending, pr_url) {
1882 let ja = crate::lang::is_japanese(&state.config.graph.language);
1883 let first = failure_headline(reason);
1884 let cause = first.map(|l| format!(" ({l})")).unwrap_or_default();
1885 if ja {
1886 let target = version.map(|v| format!(" v{v}")).unwrap_or_default();
1887 format!(
1888 "既存のリリース PR {url} を{target}へ更新できませんでした{cause}。PR を手で更新してください"
1889 )
1890 } else {
1891 let target = version.map(|v| format!(" to v{v}")).unwrap_or_default();
1892 format!(
1893 "the pending release pull request {url} could not be updated{target}{cause}; update it by hand"
1894 )
1895 }
1896 } else if pr_url.is_some() {
1897 automerge_hint(reason).to_owned()
1898 } else {
1899 let ja = crate::lang::is_japanese(&state.config.graph.language);
1900 let first = failure_headline(reason);
1901 if ja {
1902 let target = version.map(|v| format!(" (v{v})")).unwrap_or_default();
1903 let cause = first.map(|l| format!(" ({l})")).unwrap_or_default();
1904 format!(
1905 "リリースバンプ{target}は実行されませんでした{cause}。リリース PR を手で開いてください"
1906 )
1907 } else {
1908 let target = version.map(|v| format!(" to v{v}")).unwrap_or_default();
1909 let cause = first.map(|l| format!(" ({l})")).unwrap_or_default();
1910 format!(
1911 "the release bump{target} did not run{cause}; open the release pull request by hand"
1912 )
1913 }
1914 };
1915 let record = state.release_bump.get_or_insert_with(Default::default);
1916 record.pr_url = pr_url.map(str::to_owned).or(record.pr_url.take());
1917 record.version = version.map(str::to_owned).or(record.version.take());
1918 record.automerge_enabled = false;
1919 record.problem = Some(reason.to_owned());
1920 record.action_required = Some(action.clone());
1921
1922 let mut notice = Notice::error(
1923 &format!("release-bump:{}", state.id),
1924 format!(
1925 "Run {} merged, but its release step failed: {action}.",
1926 state.id
1927 ),
1928 );
1929 notice = match pr_url {
1930 Some(url) => notice.link(Link::Url {
1931 url: url.to_owned(),
1932 }),
1933 None => notice.link(Link::Run {
1934 id: state.id.clone(),
1935 }),
1936 };
1937 let notice = store
1938 .raise_with(
1939 notice
1940 .about([state.id.clone()])
1941 .for_run(Some(state.id.clone())),
1942 &state.config.notify,
1943 )
1944 .context("raise the release-bump notification")?;
1945 state.event("bump", format!("needs attention: {action}"));
1946 let comment = pr_url
1947 .filter(|_| !pending)
1948 .map(|_| automerge_failure_comment(reason));
1949 Ok((notice, comment))
1950}
1951
1952pub async fn report_problem(
1957 state: &mut RunState,
1958 pr_url: Option<&str>,
1959 version: Option<&str>,
1960 reason: &str,
1961) {
1962 report_problem_in(state, &Notices::open(), pr_url, version, reason, false).await;
1963}
1964
1965async fn report_problem_in(
1967 state: &mut RunState,
1968 store: &Notices,
1969 pr_url: Option<&str>,
1970 version: Option<&str>,
1971 reason: &str,
1972 pending: bool,
1973) {
1974 match surface_problem_in(state, store, pr_url, version, reason, pending) {
1975 Ok((_notice, comment)) => {
1976 if let (Some(url), Some(body)) = (pr_url, comment)
1977 && let Err(e) = gh_pr_comment(state, url, &body).await
1978 {
1979 state.event("bump", format!("could not comment on {url}: {e:#}"));
1980 }
1981 }
1982 Err(e) => state.event("bump", format!("could not raise a notice: {e:#}")),
1983 }
1984}
1985
1986pub(crate) async fn gh_pr_comment(state: &mut RunState, pr_url: &str, body: &str) -> Result<()> {
1987 let (_, body) = crate::github_text::prepare(state, "", body);
1988 let cwd = &state.repo;
1989 let out = tokio::process::Command::new("gh")
1990 .args(["pr", "comment", pr_url, "--body", &body])
1991 .current_dir(cwd)
1992 .quiet()
1993 .stdin(std::process::Stdio::null())
1994 .output()
1995 .await
1996 .context("spawn gh pr comment")?;
1997 if out.status.success() {
1998 Ok(())
1999 } else {
2000 bail!(
2001 "gh pr comment: {}",
2002 String::from_utf8_lossy(&out.stderr).trim()
2003 )
2004 }
2005}
2006
2007async fn escalate_pending(
2016 state: &mut RunState,
2017 repo: &Path,
2018 remote: &str,
2019 pending: &PendingBump,
2020 decision: &BumpDecision,
2021 base_version: &str,
2022 marker: &Path,
2023) -> Result<()> {
2024 let next = Version::parse(base_version)?
2025 .bump(decision.level)
2026 .to_string();
2027 let worktree = state.dir().join("bump");
2028 git::worktree_remove(repo, &worktree).await.ok();
2029 git::worktree_add_existing(repo, &worktree, &pending.branch, true)
2030 .await
2031 .with_context(|| format!("checking out the pending release branch {}", pending.branch))?;
2032
2033 let pushed: Result<()> = async {
2038 write_release_files(state, &worktree, &next).await?;
2039 let committed = git::commit_all(
2040 &worktree,
2041 &format!(
2042 "chore: release v{next} (supersedes v{})",
2043 pending.target_version
2044 ),
2045 )
2046 .await
2047 .context("commit the escalated version bump")?;
2048 if !committed {
2049 bail!("escalating the version bump left nothing to commit");
2050 }
2051 let pushed = git::push(&worktree, remote, &pending.branch).await?;
2052 if !pushed.ok() {
2053 bail!("pushing {} failed: {}", pending.branch, pushed.stderr);
2054 }
2055 Ok(())
2056 }
2057 .await;
2058 if let Err(e) = pushed {
2059 git::worktree_remove(repo, &worktree).await.ok();
2060 return Err(e);
2061 }
2062
2063 let (title, _) = crate::github_text::prepare(
2067 state,
2068 &format!("chore: release v{next} ({} bump)", decision.level.as_str()),
2069 "",
2070 );
2071 let title_warning = match gh_pr_edit_title(&worktree, &pending.pr_url, &title).await {
2072 Ok(()) => None,
2073 Err(e) => Some(e.to_string()),
2074 };
2075 git::worktree_remove(repo, &worktree).await.ok();
2076
2077 let marker_write = write_marker(
2078 marker,
2079 &PendingBump {
2080 target_version: next.clone(),
2081 level: decision.level,
2082 branch: pending.branch.clone(),
2083 pr_url: pending.pr_url.clone(),
2084 },
2085 );
2086 state.event(
2087 "bump",
2088 format!(
2089 "escalated the pending release bump from v{} to v{next} to a {} change ({}): {}",
2090 pending.target_version,
2091 decision.level.as_str(),
2092 decision.reason,
2093 pending.pr_url
2094 ),
2095 );
2096 if let Err(e) = marker_write {
2097 state.event(
2098 "bump",
2099 format!(
2100 "could not update the pending release bump marker to v{next}: {e:#}; a later \
2101 merge may misjudge whether it is already covered"
2102 ),
2103 );
2104 }
2105 if let Some(warning) = title_warning {
2106 state.event(
2107 "bump",
2108 format!(
2109 "pushed v{next} to {} but could not update its title: {warning}; the squashed \
2110 subject may still read the superseded version",
2111 pending.pr_url
2112 ),
2113 );
2114 }
2115 Ok(())
2116}
2117
2118async fn gh_open_pr_for_head(repo: &Path, branch: &str) -> Result<bool> {
2121 let out = tokio::process::Command::new("gh")
2122 .args([
2123 "pr", "list", "--head", branch, "--state", "open", "--json", "url",
2124 ])
2125 .current_dir(repo)
2126 .quiet()
2127 .stdin(std::process::Stdio::null())
2128 .output()
2129 .await
2130 .context("spawn gh pr list")?;
2131 if !out.status.success() {
2132 bail!(
2133 "gh pr list --head {branch}: {}",
2134 String::from_utf8_lossy(&out.stderr).trim()
2135 );
2136 }
2137 let prs: Vec<serde_json::Value> = serde_json::from_slice(&out.stdout)
2138 .with_context(|| format!("parse the pull requests headed by {branch}"))?;
2139 Ok(!prs.is_empty())
2140}
2141
2142async fn release_attempt<T, F, Fut, P, PFut>(
2151 repo: &Path,
2152 remote: &str,
2153 base: &str,
2154 worktree: &Path,
2155 branch: &str,
2156 open_pr: P,
2157 fill: F,
2158) -> Result<T>
2159where
2160 F: FnOnce(PathBuf) -> Fut,
2161 Fut: std::future::Future<Output = Result<T>>,
2162 P: Fn(String) -> PFut,
2163 PFut: std::future::Future<Output = Result<bool>>,
2164{
2165 let start = format!("{remote}/{base}");
2166 git::worktree_remove(repo, worktree).await.ok();
2167 let mut retried = false;
2168 if git::branch_exists(repo, branch).await? {
2169 reclaim_stale_branch(repo, remote, &start, branch, &open_pr).await?;
2170 retried = true;
2171 }
2172 loop {
2173 if let Err(e) = git::git(repo, &["branch", branch, &start]).await {
2178 let e = e.context("create the release branch");
2179 if !git::branch_exists(repo, branch).await.unwrap_or(false) {
2180 return Err(e);
2181 }
2182 if retried {
2184 return Err(anyhow!(
2185 "{e:#}; left {branch} in place: it is not one this attempt created"
2186 ));
2187 }
2188 retried = true;
2189 if let Err(r) = reclaim_stale_branch(repo, remote, &start, branch, &open_pr).await {
2190 return Err(anyhow!("{r:#} (after: {e:#})"));
2191 }
2192 continue;
2193 }
2194 if let Err(e) = git::worktree_add_existing(repo, worktree, branch, false).await {
2195 let e = e.context("create the release-bump worktree");
2196 return Err(discard_attempt(repo, remote, worktree, branch, e).await);
2197 }
2198 break;
2199 }
2200 match fill(worktree.to_path_buf()).await {
2201 Ok(v) => {
2202 git::worktree_remove(repo, worktree).await.ok();
2205 Ok(v)
2206 }
2207 Err(e) => Err(discard_attempt(repo, remote, worktree, branch, e).await),
2208 }
2209}
2210
2211async fn discard_attempt(
2213 repo: &Path,
2214 remote: &str,
2215 worktree: &Path,
2216 branch: &str,
2217 cause: anyhow::Error,
2218) -> anyhow::Error {
2219 git::worktree_remove(repo, worktree).await.ok();
2220 if !git::branch_exists(repo, branch).await.unwrap_or(false) {
2221 return cause;
2222 }
2223 let note = match git::remote_has_branch(repo, remote, branch).await {
2226 Ok(false) => match git::branch_delete(repo, branch).await {
2227 Ok(true) => return cause,
2228 _ => format!("could not delete the local branch {branch}"),
2229 },
2230 Ok(true) => format!("left {branch} in place: it was pushed to {remote}"),
2231 Err(e) => format!(
2232 "left {branch} in place: could not tell whether it was pushed to {remote} ({e:#})"
2233 ),
2234 };
2235 anyhow!("{cause:#}; {note}")
2236}
2237
2238async fn reclaim_stale_branch<P, PFut>(
2243 repo: &Path,
2244 remote: &str,
2245 start: &str,
2246 branch: &str,
2247 open_pr: &P,
2248) -> Result<()>
2249where
2250 P: Fn(String) -> PFut,
2251 PFut: std::future::Future<Output = Result<bool>>,
2252{
2253 match git::remote_has_branch(repo, remote, branch).await {
2254 Ok(false) => {}
2255 Ok(true) => bail!("the branch {branch} already exists and is on {remote}; left alone"),
2256 Err(e) => bail!(
2257 "the branch {branch} already exists and could not check whether {remote} has it ({e:#}); left alone"
2258 ),
2259 }
2260 match open_pr(branch.to_string()).await {
2261 Ok(false) => {}
2262 Ok(true) => {
2263 bail!("the branch {branch} already exists and has an open pull request; left alone")
2264 }
2265 Err(e) => bail!(
2266 "the branch {branch} already exists and could not check for an open pull request \
2267 ({e:#}); left alone"
2268 ),
2269 }
2270 match git::commits_ahead(repo, start, branch).await {
2271 Ok(0) => {}
2272 Ok(n) => bail!(
2273 "the branch {branch} already exists with {n} commit(s) not in {start}; left alone"
2274 ),
2275 Err(e) => bail!(
2276 "the branch {branch} already exists and could not compare it with {start} ({e:#}); \
2277 left alone"
2278 ),
2279 }
2280 if let Some(held) = git::worktree_holding(repo, branch).await? {
2281 let same = |a: &Path, b: &Path| match (a.canonicalize(), b.canonicalize()) {
2282 (Ok(a), Ok(b)) => a == b,
2283 _ => a == b,
2284 };
2285 if same(&held, repo) {
2286 bail!(
2287 "the branch {branch} already exists and is checked out in the main checkout; left alone"
2288 );
2289 }
2290 git::worktree_remove(repo, &held).await.ok();
2291 }
2292 if !git::branch_delete(repo, branch).await? {
2293 bail!("the branch {branch} already exists and could not be deleted; left alone");
2294 }
2295 Ok(())
2296}
2297
2298async fn open_bump_pr(
2304 state: &mut RunState,
2305 worktree: &Path,
2306 branch: &str,
2307 next_version: &str,
2308 decision: &BumpDecision,
2309 source_pr_url: &str,
2310) -> Result<(String, AutomergeOutcome)> {
2311 write_release_files(state, worktree, next_version).await?;
2312
2313 let committed = git::commit_all(worktree, &format!("chore: release v{next_version}"))
2314 .await
2315 .context("commit the version bump")?;
2316 if !committed {
2317 bail!("the version bump left nothing to commit");
2318 }
2319
2320 let remote = state.config.merge.remote.clone();
2321 let pushed = git::push(worktree, &remote, branch).await?;
2322 if !pushed.ok() {
2323 bail!("pushing {branch} failed: {}", pushed.stderr);
2324 }
2325
2326 let (title, body) = release_pr(
2327 decision.level.as_str(),
2328 &decision.reason,
2329 next_version,
2330 &state.id,
2331 source_pr_url,
2332 );
2333 let (title, body) = crate::github_text::prepare(state, &title, &body);
2334 let url = gh_pr_create(worktree, &state.base_branch, branch, &title, &body).await?;
2335 if state.config.release.is_local() {
2339 crate::release_watch::register(&crate::run::home(), &state.repo, &url, &state.id);
2342 return Ok((url, AutomergeOutcome::LocalGate));
2343 }
2344 let outcome = match gh_enable_automerge(worktree, &url).await {
2345 Ok(()) => AutomergeOutcome::Enabled,
2346 Err(e) => {
2347 let reason = e.to_string();
2348 if is_clean_status_refusal(&reason) {
2349 gh_merge_directly(worktree, &url, &title, reason).await
2350 } else {
2351 AutomergeOutcome::Failed { reason }
2352 }
2353 }
2354 };
2355 Ok((url, outcome))
2356}
2357
2358#[derive(Debug, Clone, PartialEq, Eq)]
2360enum AutomergeOutcome {
2361 Enabled,
2363 MergedDirectly { detail: String },
2365 LocalGate,
2367 Failed { reason: String },
2369}
2370
2371fn is_clean_status_refusal(reason: &str) -> bool {
2377 let r = reason.to_lowercase();
2378 r.contains("is in clean status") && r.contains("enablepullrequestautomerge")
2379}
2380
2381pub(crate) fn bump_merge_argv(pr_url: &str, subject: &str) -> Vec<String> {
2384 [
2385 "pr",
2386 "merge",
2387 pr_url,
2388 "--squash",
2389 "--delete-branch",
2390 "--subject",
2391 subject,
2392 ]
2393 .map(str::to_owned)
2394 .to_vec()
2395}
2396
2397fn resolve_direct_merge(
2401 refusal: &str,
2402 argv: &[String],
2403 merge_ok: bool,
2404 stderr: &str,
2405 after: Option<land::PrLifecycle>,
2406) -> AutomergeOutcome {
2407 if merge_ok {
2408 return AutomergeOutcome::MergedDirectly {
2409 detail: format!("automerge was refused ({refusal}); gh {}", argv.join(" ")),
2410 };
2411 }
2412 match land::merged_after_all(argv, stderr, after) {
2413 Some(m) => AutomergeOutcome::MergedDirectly { detail: m.detail },
2414 None => AutomergeOutcome::Failed {
2415 reason: format!("{refusal}; merging directly failed too: {}", stderr.trim()),
2416 },
2417 }
2418}
2419
2420async fn gh_merge_directly(
2424 cwd: &Path,
2425 pr_url: &str,
2426 subject: &str,
2427 refusal: String,
2428) -> AutomergeOutcome {
2429 let argv = bump_merge_argv(pr_url, subject);
2430 let out = match tokio::process::Command::new("gh")
2431 .args(&argv)
2432 .current_dir(cwd)
2433 .quiet()
2434 .stdin(std::process::Stdio::null())
2435 .output()
2436 .await
2437 {
2438 Ok(o) => o,
2439 Err(e) => {
2440 return AutomergeOutcome::Failed {
2441 reason: format!("{refusal}; could not spawn gh to merge directly: {e}"),
2442 };
2443 }
2444 };
2445 let stderr = String::from_utf8_lossy(&out.stderr).into_owned();
2446 let after = if out.status.success() {
2449 None
2450 } else {
2451 land::lifecycle(cwd, pr_url).await.ok()
2452 };
2453 resolve_direct_merge(&refusal, &argv, out.status.success(), &stderr, after)
2454}
2455
2456async fn write_release_files(state: &RunState, worktree: &Path, version: &str) -> Result<()> {
2460 let declared = &state.config.release.version_files;
2461 if release_manifest::is_custom(declared) {
2462 return release_manifest::apply(worktree, declared, version);
2463 }
2464 let cargo_toml_path = worktree.join("Cargo.toml");
2465 let toml = tokio::fs::read_to_string(&cargo_toml_path)
2466 .await
2467 .with_context(|| format!("read {}", cargo_toml_path.display()))?;
2468 let rewritten = rewrite_cargo_version(&toml, version)?;
2469 tokio::fs::write(&cargo_toml_path, rewritten)
2470 .await
2471 .with_context(|| format!("write {}", cargo_toml_path.display()))?;
2472 if crate::build_target::isolated(&state.config) {
2473 let shell = state.config.shell();
2474 crate::build_target::command::check_shell(&shell)?;
2475 let mut build = crate::build_target::Operation::admit(
2476 &state.config,
2477 worktree,
2478 &state.id,
2479 "bump-lockfile",
2480 crate::build_target::Coordination::Acquire,
2481 )
2482 .await?;
2483 if let Some(output) = crate::retention::OutputLease::borrow(worktree)? {
2484 build.outputs.push(output);
2485 }
2486 return crate::worktree_setup::run_command(
2487 &shell,
2488 "cargo build",
2489 worktree,
2490 Duration::from_secs(state.config.graph.verify_timeout()),
2491 build.lease.take(),
2492 std::mem::take(&mut build.outputs),
2493 false,
2494 Some((&build.target, state.config.disk.min_free_bytes)),
2495 )
2496 .await;
2497 }
2498 sync_lockfile(worktree, state.config.cache_dir().as_deref()).await
2499}
2500
2501async fn sync_lockfile(worktree: &Path, cache_dir: Option<&Path>) -> Result<()> {
2509 let mut cmd = tokio::process::Command::new("cargo");
2510 cmd.arg("build").current_dir(worktree).quiet();
2511 crate::incremental::configure(&mut cmd, worktree)?;
2512 if let Some(dir) = cache_dir {
2513 cmd.env("CARGO_TARGET_DIR", dir);
2514 }
2515 let out = cmd
2516 .stdin(std::process::Stdio::null())
2517 .output()
2518 .await
2519 .context("spawn cargo build")?;
2520 if !out.status.success() {
2521 bail!(
2522 "cargo build failed while syncing Cargo.lock: {}",
2523 String::from_utf8_lossy(&out.stderr).trim()
2524 );
2525 }
2526 Ok(())
2527}
2528
2529fn release_pr(
2534 level: &str,
2535 reason: &str,
2536 next_version: &str,
2537 run_id: &str,
2538 source_pr_url: &str,
2539) -> (String, String) {
2540 let title = format!("chore: release v{next_version} ({level} bump)");
2541 let body = format!(
2542 "## Background\n\n\
2543 A change that was just merged is a `{level}` change, so the crate needs a new \
2544 release: {reason}\n\n\
2545 Triggered by magi run `{run_id}`, which landed {source}.\n\n\
2546 ## Change\n\n\
2547 Raises the package version to `v{next_version}` in `Cargo.toml`, with \
2548 `Cargo.lock` following it. Nothing else changes.\n\n\
2549 ## Risk\n\n\
2550 Version-bump-only, so there is nothing here for a reviewer to find. Merging \
2551 it starts the release pipeline (auto-tag, then the release workflow).",
2552 source = source_pr_url,
2553 );
2554 (title, body)
2555}
2556
2557async fn pr_title(repo: &Path, pr_url: &str) -> Result<String> {
2559 let out = tokio::process::Command::new("gh")
2560 .args(["pr", "view", pr_url, "--json", "title"])
2561 .current_dir(repo)
2562 .quiet()
2563 .stdin(std::process::Stdio::null())
2564 .output()
2565 .await
2566 .context("spawn gh pr view")?;
2567 if !out.status.success() {
2568 bail!(
2569 "gh pr view {pr_url}: {}",
2570 String::from_utf8_lossy(&out.stderr).trim()
2571 );
2572 }
2573 #[derive(Deserialize)]
2574 struct Title {
2575 title: String,
2576 }
2577 let parsed: Title = serde_json::from_str(&String::from_utf8_lossy(&out.stdout))
2578 .context("parse `gh pr view --json title` output")?;
2579 Ok(parsed.title)
2580}
2581
2582async fn gh_pr_create(
2583 cwd: &Path,
2584 base: &str,
2585 head: &str,
2586 title: &str,
2587 body: &str,
2588) -> Result<String> {
2589 let out = tokio::process::Command::new("gh")
2590 .args([
2591 "pr", "create", "--base", base, "--head", head, "--title", title, "--body", body,
2592 ])
2593 .current_dir(cwd)
2594 .quiet()
2595 .stdin(std::process::Stdio::null())
2596 .output()
2597 .await
2598 .context("spawn gh pr create")?;
2599 if out.status.success() {
2600 Ok(String::from_utf8_lossy(&out.stdout).trim().to_owned())
2601 } else {
2602 bail!(
2603 "gh pr create: {}",
2604 String::from_utf8_lossy(&out.stderr).trim()
2605 )
2606 }
2607}
2608
2609async fn gh_enable_automerge(cwd: &Path, pr_url: &str) -> Result<()> {
2613 let out = tokio::process::Command::new("gh")
2614 .args([
2615 "pr",
2616 "merge",
2617 pr_url,
2618 "--auto",
2619 "--squash",
2620 "--delete-branch",
2621 ])
2622 .current_dir(cwd)
2623 .quiet()
2624 .stdin(std::process::Stdio::null())
2625 .output()
2626 .await
2627 .context("spawn gh pr merge --auto")?;
2628 if out.status.success() {
2629 Ok(())
2630 } else {
2631 bail!(
2632 "gh pr merge --auto: {}",
2633 String::from_utf8_lossy(&out.stderr).trim()
2634 )
2635 }
2636}
2637
2638async fn gh_pr_edit_title(cwd: &Path, pr_url: &str, title: &str) -> Result<()> {
2642 let out = tokio::process::Command::new("gh")
2643 .args(["pr", "edit", pr_url, "--title", title])
2644 .current_dir(cwd)
2645 .quiet()
2646 .stdin(std::process::Stdio::null())
2647 .output()
2648 .await
2649 .context("spawn gh pr edit")?;
2650 if out.status.success() {
2651 Ok(())
2652 } else {
2653 bail!(
2654 "gh pr edit --title: {}",
2655 String::from_utf8_lossy(&out.stderr).trim()
2656 )
2657 }
2658}
2659
2660#[cfg(test)]
2661mod tests {
2662 use super::*;
2663 use crate::notices::Severity;
2664
2665 #[test]
2666 fn github_facing_bump_text_is_english() {
2667 let (title, body) =
2668 release_pr("minor", "adds a flag", "0.37.0", "ab12", "https://x/pull/1");
2669 assert!(crate::github_text::check(&title, &body).is_empty());
2670 assert!(title.is_ascii() && body.is_ascii(), "{title}\n{body}");
2671 assert_eq!(title, "chore: release v0.37.0 (minor bump)");
2672 assert!(
2673 body.contains("## Background") && body.contains("## Change"),
2674 "{body}"
2675 );
2676 let p = decision_prompt("s", "i", "d", &[], "0.36.5");
2677 assert!(p.contains(crate::prompt::GITHUB_ENGLISH_HEADING), "{p}");
2678 }
2679 use crate::config::Config;
2680 use crate::land::PrLifecycle;
2681
2682 #[tokio::test]
2688 async fn a_disabled_config_does_nothing() {
2689 let config = Config {
2690 merge: crate::config::Merge {
2691 release_bump: false,
2692 ..crate::config::Merge::default()
2693 },
2694 ..Config::default()
2695 };
2696 let mut state = RunState::new(
2697 PathBuf::from("/no/such/repo"),
2698 "main".to_owned(),
2699 "0000000000000000000000000000000000000000".to_owned(),
2700 "irrelevant".to_owned(),
2701 config,
2702 );
2703 after_merge(&mut state, "https://example.invalid/pull/1")
2704 .await
2705 .expect("a disabled config must return Ok without touching anything");
2706 assert!(
2707 state.events.is_empty(),
2708 "nothing should happen at all, not even a logged event"
2709 );
2710 }
2711
2712 async fn origin_with(files: &[(&str, &str)]) -> (tempfile::TempDir, PathBuf) {
2714 let dir = tempfile::tempdir().unwrap();
2715 let origin = dir.path().join("origin.git");
2716 let repo = dir.path().join("repo");
2717 let o = origin.to_string_lossy().into_owned();
2718 git::git(dir.path(), &["init", "--bare", "-b", "main", &o])
2719 .await
2720 .unwrap();
2721 tokio::fs::create_dir_all(&repo).await.unwrap();
2722 git::git(&repo, &["init", "-b", "main"]).await.unwrap();
2723 git::git(&repo, &["config", "user.name", "test"])
2724 .await
2725 .unwrap();
2726 git::git(&repo, &["config", "user.email", "test@example.com"])
2727 .await
2728 .unwrap();
2729 for (name, body) in files {
2730 tokio::fs::write(repo.join(name), body).await.unwrap();
2731 }
2732 git::git(&repo, &["add", "-A"]).await.unwrap();
2733 git::git(&repo, &["commit", "-m", "init"]).await.unwrap();
2734 git::git(&repo, &["remote", "add", "origin", &o])
2735 .await
2736 .unwrap();
2737 git::git(&repo, &["push", "origin", "main"]).await.unwrap();
2738 (dir, repo)
2739 }
2740
2741 async fn no_pr(_: String) -> Result<bool> {
2742 Ok(false)
2743 }
2744
2745 async fn with_branch(ahead: bool) -> (tempfile::TempDir, PathBuf) {
2748 let (d, repo) = origin_with(&[("f", "x\n")]).await;
2749 git::git(&repo, &["branch", "b"]).await.unwrap();
2750 if ahead {
2751 git::git(&repo, &["checkout", "-q", "b"]).await.unwrap();
2752 git::git(&repo, &["commit", "--allow-empty", "-m", "wip"])
2753 .await
2754 .unwrap();
2755 git::git(&repo, &["checkout", "-q", "main"]).await.unwrap();
2756 }
2757 (d, repo)
2758 }
2759
2760 async fn attempt(repo: &Path, open_pr: bool, fail_after_push: Option<bool>) -> Result<()> {
2761 let wt = repo.parent().unwrap().join("bump");
2762 release_attempt(
2763 repo,
2764 "origin",
2765 "main",
2766 &wt,
2767 "b",
2768 |_| async move { Ok(open_pr) },
2769 |w| async move {
2770 if fail_after_push == Some(true) {
2771 git::push(&w, "origin", "b").await?;
2772 }
2773 if fail_after_push.is_some() {
2774 bail!("cargo build failed");
2775 }
2776 Ok(())
2777 },
2778 )
2779 .await
2780 }
2781
2782 #[tokio::test]
2783 async fn a_stale_ancestor_branch_is_deleted_and_the_attempt_proceeds() {
2784 let (_d, repo) = with_branch(false).await;
2785 attempt(&repo, false, None).await.unwrap();
2786 assert!(git::branch_exists(&repo, "b").await.unwrap());
2788 }
2789
2790 #[tokio::test]
2791 async fn a_stale_branch_holding_a_leftover_worktree_is_reclaimed() {
2792 let (_d, repo) = with_branch(false).await;
2793 let old = repo.parent().unwrap().join("old");
2794 git::git(&repo, &["worktree", "add", &old.to_string_lossy(), "b"])
2795 .await
2796 .unwrap();
2797 attempt(&repo, false, None).await.unwrap();
2798 assert!(!old.exists());
2799 }
2800
2801 #[tokio::test]
2802 async fn a_stale_branch_with_an_unmerged_commit_is_kept_with_a_reason() {
2803 let (_d, repo) = with_branch(true).await;
2804 let e = attempt(&repo, false, None).await.unwrap_err().to_string();
2805 assert!(e.contains("`b`") || e.contains("branch b"), "{e}");
2806 assert!(e.contains("1 commit(s) not in origin/main"), "{e}");
2807 assert!(git::branch_exists(&repo, "b").await.unwrap());
2808 }
2809
2810 #[tokio::test]
2811 async fn a_stale_branch_on_the_remote_is_kept() {
2812 let (_d, repo) = with_branch(false).await;
2813 git::git(&repo, &["push", "origin", "b"]).await.unwrap();
2814 let e = attempt(&repo, false, None).await.unwrap_err().to_string();
2815 assert!(e.contains("branch b") && e.contains("is on origin"), "{e}");
2816 assert!(git::branch_exists(&repo, "b").await.unwrap());
2817 }
2818
2819 #[tokio::test]
2820 async fn a_stale_branch_with_an_open_pull_request_is_kept() {
2821 let (_d, repo) = with_branch(false).await;
2822 let e = attempt(&repo, true, None).await.unwrap_err().to_string();
2823 assert!(e.contains("open pull request"), "{e}");
2824 assert!(git::branch_exists(&repo, "b").await.unwrap());
2825 }
2826
2827 #[tokio::test]
2828 async fn an_unanswerable_pull_request_check_keeps_the_branch() {
2829 let (_d, repo) = with_branch(false).await;
2830 let wt = repo.parent().unwrap().join("bump");
2831 let e = release_attempt(
2832 &repo,
2833 "origin",
2834 "main",
2835 &wt,
2836 "b",
2837 |_| async { bail!("offline") },
2838 |_| async { Ok(()) },
2839 )
2840 .await
2841 .unwrap_err()
2842 .to_string();
2843 assert!(
2844 e.contains("could not check for an open pull request"),
2845 "{e}"
2846 );
2847 assert!(git::branch_exists(&repo, "b").await.unwrap());
2848 }
2849
2850 #[tokio::test]
2851 async fn a_failed_attempt_removes_its_own_worktree_and_branch() {
2852 let (_d, repo) = origin_with(&[("f", "x\n")]).await;
2853 let wt = repo.parent().unwrap().join("bump");
2854 let e = attempt(&repo, false, Some(false)).await.unwrap_err();
2855 assert!(format!("{e:#}").contains("cargo build failed"));
2856 assert!(!wt.exists());
2857 assert!(!git::branch_exists(&repo, "b").await.unwrap());
2858 }
2859
2860 #[tokio::test]
2861 async fn release_worktrees_accept_canonical_paths_from_a_detached_checkout() {
2862 let (dir, repo) = origin_with(&[("f", "remote base\n")]).await;
2863 let base = git::rev_parse(&repo, "origin/main").await.unwrap();
2864 tokio::fs::write(repo.join("f"), "local only\n")
2866 .await
2867 .unwrap();
2868 git::git(&repo, &["commit", "-am", "local only"])
2869 .await
2870 .unwrap();
2871 git::git(&repo, &["checkout", "--detach"]).await.unwrap();
2872 let root = std::fs::canonicalize(dir.path()).unwrap();
2875 let worktree = root.join("release bump");
2876 let head = release_attempt(
2877 &repo,
2878 "origin",
2879 "main",
2880 &worktree,
2881 "release-test",
2882 no_pr,
2883 |path| async move {
2884 assert_eq!(
2887 tokio::fs::read_to_string(path.join("f"))
2888 .await
2889 .unwrap()
2890 .replace("\r\n", "\n"),
2891 "remote base\n"
2892 );
2893 git::rev_parse(&path, "HEAD").await
2894 },
2895 )
2896 .await
2897 .unwrap();
2898 assert_eq!(head, base);
2899 assert!(!worktree.exists());
2900
2901 git::worktree_add_existing(&repo, &worktree, "release-test", true)
2903 .await
2904 .unwrap();
2905 assert_eq!(git::rev_parse(&worktree, "HEAD").await.unwrap(), base);
2906 assert_eq!(
2907 tokio::fs::read_to_string(worktree.join("f"))
2908 .await
2909 .unwrap()
2910 .replace("\r\n", "\n"),
2911 "remote base\n"
2912 );
2913 git::worktree_remove(&repo, &worktree).await.unwrap();
2914 git::branch_delete(&repo, "release-test").await.unwrap();
2915
2916 git::worktree_add_branch(&repo, &worktree, "fresh-test", "origin/main")
2917 .await
2918 .unwrap();
2919 assert_eq!(git::rev_parse(&worktree, "HEAD").await.unwrap(), base);
2920 git::worktree_remove(&repo, &worktree).await.unwrap();
2921 git::branch_delete(&repo, "fresh-test").await.unwrap();
2922 assert!(!worktree.exists());
2923 }
2924
2925 #[tokio::test]
2926 async fn a_pushed_branch_survives_a_failed_attempt_and_the_reason_says_so() {
2927 let (_d, repo) = origin_with(&[("f", "x\n")]).await;
2928 let e = attempt(&repo, false, Some(true)).await.unwrap_err();
2929 let e = format!("{e:#}");
2930 assert!(
2931 e.contains("cargo build failed") && e.contains("pushed to origin"),
2932 "{e}"
2933 );
2934 assert!(git::branch_exists(&repo, "b").await.unwrap());
2935 }
2936
2937 #[tokio::test]
2938 async fn a_branch_left_by_a_half_done_worktree_add_is_removed() {
2939 let (_d, repo) = origin_with(&[("f", "x\n")]).await;
2942 let blocker = repo.parent().unwrap().join("blocker");
2943 tokio::fs::write(&blocker, "file").await.unwrap();
2944 let wt = blocker.join("bump");
2945 let r = release_attempt(
2946 &repo,
2947 "origin",
2948 "main",
2949 &wt,
2950 "b",
2951 |_| async { bail!("offline") },
2952 |_| async { Ok(()) },
2953 )
2954 .await;
2955 assert!(r.is_err());
2956 assert!(!git::branch_exists(&repo, "b").await.unwrap());
2957 }
2958
2959 #[tokio::test]
2960 async fn the_retry_is_taken_at_most_once() {
2961 let (_d, repo) = with_branch(false).await;
2964 let blocker = repo.parent().unwrap().join("blocker");
2965 tokio::fs::write(&blocker, "file").await.unwrap();
2966 let wt = blocker.join("bump");
2967 let r = release_attempt(&repo, "origin", "main", &wt, "b", no_pr, |_| async {
2968 Ok(())
2969 })
2970 .await;
2971 assert!(r.is_err());
2972 assert!(!git::branch_exists(&repo, "b").await.unwrap());
2973 }
2974
2975 #[tokio::test]
2976 async fn release_worktree_failure_preserves_full_diagnostics_and_operator_data() {
2977 let (dir, repo) = origin_with(&[("f", "x\n")]).await;
2978 let worktree = dir.path().join("occupied");
2979 tokio::fs::create_dir(&worktree).await.unwrap();
2980 let existing = worktree.join("keep");
2981 tokio::fs::write(&existing, "operator data").await.unwrap();
2982 let err = release_attempt::<(), _, _, _, _>(
2983 &repo,
2984 "origin",
2985 "main",
2986 &worktree,
2987 "release-test",
2988 no_pr,
2989 |_| async { panic!("worktree creation must fail before release edits") },
2990 )
2991 .await
2992 .unwrap_err();
2993 let (version, reason) = notice_for_failure(&Progress::default(), &err);
2994 assert!(
2995 reason.contains("create the release-bump worktree"),
2996 "{reason}"
2997 );
2998 assert!(reason.contains("exit code 128"), "{reason}");
2999 assert!(reason.contains("Preparing worktree"), "{reason}");
3000 assert!(reason.contains("\nfatal:"), "{reason}");
3001 let store = Notices::at(dir.path().join("notifications"));
3002 let mut state = winner_state(&repo, "main");
3003 state.status = RunStatus::Merged;
3004 report_problem_in(&mut state, &store, None, version.as_deref(), &reason, false).await;
3005 let notices = store.list();
3006 assert_eq!(notices.len(), 1);
3007 let notice = ¬ices[0];
3008 assert!(notice.message.contains("fatal:"), "{}", notice.message);
3009 assert!(!notice.message.contains("Some(") && !notice.message.contains("None"));
3010 assert_eq!(notice.severity, Severity::Error);
3011 assert_eq!(state.status, RunStatus::Merged);
3012 assert!(state.needs_attention());
3013 let problem = state
3014 .release_bump
3015 .as_ref()
3016 .unwrap()
3017 .problem
3018 .as_ref()
3019 .unwrap();
3020 assert_eq!(
3021 problem,
3022 &crate::scrub::scrub(&reason, &crate::scrub::Identity::current())
3023 );
3024 let saved = serde_json::to_string(&state).unwrap();
3025 let restored: RunState = serde_json::from_str(&saved).unwrap();
3026 assert_eq!(
3027 restored.release_bump.as_ref().unwrap().problem.as_ref(),
3028 Some(problem)
3029 );
3030 assert!(crate::report::run(&restored).contains("fatal:"));
3031 assert!(!git::branch_exists(&repo, "release-test").await.unwrap());
3032 assert_eq!(
3033 tokio::fs::read_to_string(existing).await.unwrap(),
3034 "operator data"
3035 );
3036 }
3037
3038 #[tokio::test]
3039 async fn base_has_cargo_toml_tells_rust_from_non_rust() {
3040 let (_d, rust) = origin_with(&[("Cargo.toml", "[package]\nversion = \"0.1.0\"\n")]).await;
3041 assert!(base_has_cargo_toml(&rust, "origin", "main").await.unwrap());
3042 let (_d2, other) = origin_with(&[("README.md", "hi\n")]).await;
3043 assert!(!base_has_cargo_toml(&other, "origin", "main").await.unwrap());
3044 assert!(base_has_cargo_toml(&other, "origin", "nope").await.is_err());
3046 }
3047
3048 #[tokio::test]
3049 async fn a_repo_without_cargo_toml_skips_with_one_event_and_no_lock() {
3050 let (_d, repo) = origin_with(&[("README.md", "hi\n")]).await;
3051 let home = tempfile::tempdir().unwrap();
3052 let mut state = RunState::new(
3053 repo.clone(),
3054 "main".to_owned(),
3055 "0000000000000000000000000000000000000000".to_owned(),
3056 "task".to_owned(),
3057 Config::default(),
3058 );
3059 state.candidates.push(crate::run::Candidate {
3060 index: 0,
3061 label: 'A',
3062 agent: "x".to_owned(),
3063 branch: "main".to_owned(),
3064 worktree: repo.clone(),
3065 summary: String::new(),
3066 stat: String::new(),
3067 files: 1,
3068 commits: 1,
3069 empty: false,
3070 failed: None,
3071 verified_noop: None,
3072 duration_ms: 0,
3073 folded: false,
3074 });
3075 state.tally = Some(
3076 serde_json::from_value(serde_json::json!({
3077 "first_choice": {}, "borda": {}, "winner": "A",
3078 "unanimous_initial": true, "deliberated": false,
3079 "changed_votes": 0, "unanimous_final": true,
3080 }))
3081 .unwrap(),
3082 );
3083 after_merge_at(
3084 &mut state,
3085 "https://example.invalid/pull/1",
3086 Some(home.path()),
3087 None,
3088 )
3089 .await
3090 .expect("a non-Rust repository is not an error");
3091 let bumps: Vec<_> = state.events.iter().filter(|e| e.node == "bump").collect();
3092 assert_eq!(bumps.len(), 1, "{:?}", state.events);
3093 assert_eq!(
3094 bumps[0].message,
3095 "release bump: no Cargo.toml on the base branch; release bumps are Rust-only, skipping"
3096 );
3097 assert!(
3098 std::fs::read_dir(home.path()).unwrap().next().is_none(),
3099 "no marker and no lock may be created"
3100 );
3101 }
3102
3103 fn winner_state(repo: &Path, base: &str) -> RunState {
3104 let mut state = RunState::new(
3105 repo.to_path_buf(),
3106 base.to_owned(),
3107 "0000000000000000000000000000000000000000".to_owned(),
3108 "task".to_owned(),
3109 Config::default(),
3110 );
3111 state.candidates.push(crate::run::Candidate {
3112 index: 0,
3113 label: 'A',
3114 agent: "x".to_owned(),
3115 branch: "main".to_owned(),
3116 worktree: repo.to_path_buf(),
3117 summary: String::new(),
3118 stat: String::new(),
3119 files: 1,
3120 commits: 1,
3121 empty: false,
3122 failed: None,
3123 verified_noop: None,
3124 duration_ms: 0,
3125 folded: false,
3126 });
3127 state.tally = Some(
3128 serde_json::from_value(serde_json::json!({
3129 "first_choice": {}, "borda": {}, "winner": "A",
3130 "unanimous_initial": true, "deliberated": false,
3131 "changed_votes": 0, "unanimous_final": true,
3132 }))
3133 .unwrap(),
3134 );
3135 state
3136 }
3137
3138 #[tokio::test]
3139 async fn a_real_failure_without_a_pr_raises_one_notice_and_a_retry_folds_into_it() {
3140 let (_d, repo) =
3141 origin_with(&[("Cargo.toml", "[package]\nname=\"x\"\nversion=\"0.1.0\"\n")]).await;
3142 let home = tempfile::tempdir().unwrap();
3143 let store = Notices::at(home.path().join("notifications"));
3144 let mut state = winner_state(&repo, "nope");
3146 let url = "https://example.invalid/pull/1";
3147 after_merge_at(&mut state, url, Some(home.path()), Some(&store))
3148 .await
3149 .expect_err("an unresolvable base is a failure");
3150 let listed = store.list();
3151 assert_eq!(listed.len(), 1, "{listed:?}");
3152 assert!(state.events.iter().any(|e| e.node == "bump"));
3153 after_merge_at(&mut state, url, Some(home.path()), Some(&store))
3154 .await
3155 .expect_err("still failing");
3156 let listed = store.list();
3157 assert_eq!(listed.len(), 1, "{listed:?}");
3158 assert_eq!(listed[0].count, 2);
3159 }
3160
3161 #[tokio::test]
3162 async fn not_eligible_cases_raise_no_notice() {
3163 let home = tempfile::tempdir().unwrap();
3164 let store = Notices::at(home.path().join("notifications"));
3165 let url = "https://example.invalid/pull/1";
3166 let (_d, repo) = origin_with(&[("README.md", "hi\n")]).await;
3168 let mut state = winner_state(&repo, "main");
3169 after_merge_at(&mut state, url, Some(home.path()), Some(&store))
3170 .await
3171 .unwrap();
3172 let mut state = winner_state(&repo, "nope");
3174 state.config.merge.release_bump = false;
3175 after_merge_at(&mut state, url, Some(home.path()), Some(&store))
3176 .await
3177 .unwrap();
3178 let mut state = winner_state(&repo, "nope");
3180 state.tally = None;
3181 after_merge_at(&mut state, url, Some(home.path()), Some(&store))
3182 .await
3183 .unwrap();
3184 assert!(store.list().is_empty(), "{:?}", store.list());
3185 }
3186
3187 #[test]
3188 fn the_no_pr_notice_follows_the_configured_language() {
3189 let dir = tempfile::tempdir().unwrap();
3190 let store = Notices::at(dir.path().join("notifications"));
3191 let mut state = merged_state();
3192 state.config.graph.language = "ja".to_owned();
3193 let (n, _) = surface_problem(&mut state, &store, None, Some("0.2.0"), "boom").unwrap();
3194 assert!(n.message.contains("実行されませんでした"), "{}", n.message);
3195 assert!(n.message.contains("boom") && n.message.contains("v0.2.0"));
3196 }
3197
3198 #[test]
3199 fn a_failed_escalation_points_at_the_pending_pr_without_commenting() {
3200 let dir = tempfile::tempdir().unwrap();
3201 let store = Notices::at(dir.path().join("notifications"));
3202 let mut state = merged_state();
3203 let url = "https://example.invalid/pull/9";
3204 let (n, comment) = surface_problem_in(
3205 &mut state,
3206 &store,
3207 Some(url),
3208 Some("0.3.0"),
3209 "push failed",
3210 true,
3211 )
3212 .unwrap();
3213 assert!(comment.is_none());
3214 assert!(
3215 n.message.contains(url) && n.message.contains("v0.3.0"),
3216 "{}",
3217 n.message
3218 );
3219 assert!(!n.message.contains("open the release pull request by hand"));
3220 assert!(matches!(n.link, Some(Link::Url { .. })));
3221 }
3222
3223 #[test]
3224 fn a_failure_notice_preserves_the_full_error_chain() {
3225 let err = anyhow!("outer context").context("cargo build failed\nsecond line");
3226 let with_pr = Progress {
3227 version: Some("0.2.0".into()),
3228 pending_pr: Some("https://example.invalid/pull/9".into()),
3229 skip: None,
3230 };
3231 let (v, reason) = notice_for_failure(&with_pr, &err);
3232 assert_eq!(v.as_deref(), Some("0.2.0"));
3233 assert_eq!(reason, "cargo build failed\nsecond line: outer context");
3234 let (v, reason) = notice_for_failure(&Progress::default(), &err);
3235 assert_eq!(v, None);
3236 assert_eq!(reason, "cargo build failed\nsecond line: outer context");
3237 }
3238
3239 #[test]
3240 fn failure_headline_prefers_git_errors_and_skips_blank_lines() {
3241 assert_eq!(
3242 failure_headline("checkout failed\nPreparing worktree\n fatal: invalid path\n"),
3243 Some("fatal: invalid path")
3244 );
3245 assert_eq!(
3246 failure_headline("Preparing worktree\n error: checkout failed\n"),
3247 Some("error: checkout failed")
3248 );
3249 assert_eq!(
3250 failure_headline("\n \n first cause \nsecond"),
3251 Some("first cause")
3252 );
3253 assert_eq!(failure_headline(" \n\t"), None);
3254 }
3255
3256 const NO_RULES: &str = "gh pr merge --auto: GraphQL: Pull request Branch does not have \
3257 required protected branch rules (enablePullRequestAutoMerge)";
3258
3259 fn merged_state() -> RunState {
3260 run::pin_test_home();
3263 let mut s = RunState::new(
3264 PathBuf::from("/no/such/repo"),
3265 "main".to_owned(),
3266 "0000000000000000000000000000000000000000".to_owned(),
3267 "task".to_owned(),
3268 Config::default(),
3269 );
3270 s.status = RunStatus::Merged;
3271 s
3272 }
3273
3274 #[cfg(unix)]
3275 fn decision_cli(id: &str, reply: &str, exit: &str) -> AgentSpec {
3276 AgentSpec {
3277 id: id.into(),
3278 kind: crate::config::AgentKind::Command,
3279 model: None,
3280 command: vec![
3281 "sh".into(),
3282 "-c".into(),
3283 concat!(
3284 "if [ \"$STATUS\" = timeout ]; then exec sleep 5; fi; ",
3285 "printf '%s' \"$REPLY\"; exit \"$STATUS\""
3286 )
3287 .into(),
3288 ],
3289 extra_args: Vec::new(),
3290 env: std::collections::BTreeMap::from([
3291 ("REPLY".into(), reply.into()),
3292 ("STATUS".into(), exit.into()),
3293 ]),
3294 prompt_delivery: None,
3295 max_turn_secs: None,
3296 }
3297 }
3298
3299 #[cfg(unix)]
3300 fn decision_state(agents: Vec<AgentSpec>, preferences: &[&str]) -> RunState {
3301 let mut state = merged_state();
3302 state.config.agents = agents;
3303 state.config.roles.chatter = Some(crate::config::AgentChoice::Chain(
3304 preferences.iter().map(|s| (*s).to_owned()).collect(),
3305 ));
3306 state
3307 }
3308
3309 #[cfg(unix)]
3310 const VALID_DECISION: &str = r#"{"level":"minor","reason":"Adds a feature."}"#;
3311
3312 #[cfg(unix)]
3313 #[tokio::test]
3314 async fn decision_failover_handles_each_unusable_cli_outcome() {
3315 for (reply, exit, expected) in [
3316 (
3317 r#"{"is_error":true,"api_error_status":429,"api_error":"usage_limit_reached"}"#,
3318 "1",
3319 "rate/quota limit",
3320 ),
3321 (
3322 r#"{"is_error":true,"api_error_status":429,"api_error":"usage_limit_reached","level":"minor","reason":"Looks valid."}"#,
3323 "0",
3324 "rate/quota limit",
3325 ),
3326 (
3327 r#"{"is_error":true,"api_error_status":"429","api_error":"usage_limit_reached","level":"minor","reason":"Looks valid."}"#,
3328 "0",
3329 "rate/quota limit",
3330 ),
3331 ("", "0", "empty output"),
3332 (
3333 "",
3334 "spawn",
3335 "CLI invocation failed; inspect attempt artifacts",
3336 ),
3337 ("not JSON", "0", "invalid decision JSON or missing reason"),
3338 (VALID_DECISION, "1", "CLI failed (exit code 1)"),
3339 ("", "timeout", "timed out"),
3340 ] {
3341 let dir = tempfile::tempdir().unwrap();
3342 let mut state = decision_state(
3343 vec![
3344 decision_cli("first", reply, exit),
3345 decision_cli("second", VALID_DECISION, "0"),
3346 ],
3347 &["first", "second"],
3348 );
3349 if exit == "spawn" {
3350 state.config.agents[0].command = vec!["magi-test-no-such-decision-cli".into()];
3351 }
3352 let (spec, seat, decision) =
3353 ask_decision(&mut state, dir.path(), "decide", Duration::from_millis(200))
3354 .await
3355 .unwrap();
3356 assert_eq!(spec.id, "second");
3357 assert_eq!(decision.level, BumpLevel::Minor);
3358 assert_eq!(state.bump_decision_attempts.len(), 2);
3359 assert_eq!(state.bump_decision_attempts[0].outcome, expected);
3360 assert_eq!(state.handovers.len(), 1);
3361 assert_eq!(state.handovers[0].to, "second");
3362 assert_ne!(
3363 seat.claude_session,
3364 SeatState::new("bump", "first", state.seed).claude_session
3365 );
3366 let report = crate::report::run(&state);
3367 assert!(report.contains(expected), "{report}");
3368 assert!(report.contains("second: valid decision"), "{report}");
3369 assert!(state.release_bump.is_none());
3370 let artifacts = agent::artifacts_dir(&state.dir());
3371 if exit != "spawn" {
3372 assert!(artifacts.join("bump-decision-1.out").exists());
3373 }
3374 assert!(artifacts.join("bump-decision-2.out").exists());
3375 }
3376 }
3377
3378 #[cfg(unix)]
3379 #[tokio::test]
3380 async fn decision_chain_respects_preferences_and_stops_on_first_success() {
3381 let dir = tempfile::tempdir().unwrap();
3382 let mut state = decision_state(
3383 vec![
3384 decision_cli("first", "bad", "1"),
3385 decision_cli("second", VALID_DECISION, "0"),
3386 ],
3387 &["missing", "second", "second", "first"],
3388 );
3389 let (spec, _, _) = ask_decision(&mut state, dir.path(), "decide", Duration::from_secs(1))
3390 .await
3391 .unwrap();
3392 assert_eq!(spec.id, "second");
3393 assert_eq!(state.bump_decision_attempts.len(), 1);
3394 assert!(state.handovers.is_empty());
3395 }
3396
3397 #[cfg(unix)]
3398 #[tokio::test]
3399 async fn decision_chain_consumes_same_failure_classes_and_preserves_unset_policy() {
3400 let dir = tempfile::tempdir().unwrap();
3401 let mut state = decision_state(
3402 vec![
3403 decision_cli("first", "bad", "0"),
3404 decision_cli("second", "bad", "0"),
3405 decision_cli("third", VALID_DECISION, "0"),
3406 ],
3407 &["first", "second", "third"],
3408 );
3409 let (spec, _, _) = ask_decision(&mut state, dir.path(), "decide", Duration::from_secs(2))
3410 .await
3411 .unwrap();
3412 assert_eq!(spec.id, "third");
3413 assert_eq!(state.bump_decision_attempts.len(), 3);
3414 assert_eq!(state.handovers.len(), 2);
3415 state.config.roles.chatter = None;
3417 let err = ask_decision(&mut state, dir.path(), "decide", Duration::from_secs(2))
3418 .await
3419 .unwrap_err();
3420 assert!(err.to_string().contains("exhausted 1 eligible agent(s)"));
3421 assert_eq!(state.bump_decision_attempts.len(), 4);
3422 }
3423
3424 #[cfg(unix)]
3425 #[tokio::test]
3426 async fn decision_reason_rewrite_failure_preserves_the_selected_level() {
3427 let dir = tempfile::tempdir().unwrap();
3428 for reply in ["invalid", r#"{"level":"patch","reason":"Fixes a defect."}"#] {
3429 let mut state = merged_state();
3430 state.config.graph.github_text_guard = true;
3431 state.config.graph.github_language = "en".into();
3432 let spec = decision_cli("chosen", reply, "0");
3433 let mut seat = SeatState::new("bump", &spec.id, state.seed);
3434 let mut decision =
3435 parse_decision(r#"{"level":"minor","reason":"新しい機能を追加しました。"}"#)
3436 .unwrap();
3437 guard_reason(
3438 &mut state,
3439 dir.path(),
3440 "decide",
3441 &spec,
3442 &mut seat,
3443 &mut decision,
3444 )
3445 .await;
3446 assert_eq!(decision.level, BumpLevel::Minor);
3447 assert_eq!(decision.reason, "The merged change requires a release.");
3448 assert!(state.handovers.is_empty());
3449 assert!(state.bump_decision_attempts.is_empty());
3450 }
3451 }
3452
3453 #[cfg(unix)]
3454 #[tokio::test]
3455 async fn decision_exhaustion_is_bounded_reported_and_leaves_no_release_outcome() {
3456 let dir = tempfile::tempdir().unwrap();
3457 let mut state = decision_state(
3458 vec![
3459 decision_cli("first", "bad", "0"),
3460 decision_cli("second", "", "0"),
3461 ],
3462 &["first", "first", "second", "second"],
3463 );
3464 let err = ask_decision(&mut state, dir.path(), "decide", Duration::from_secs(1))
3465 .await
3466 .unwrap_err()
3467 .to_string();
3468 assert!(err.contains("exhausted 2 eligible agent(s)"), "{err}");
3469 assert!(err.contains("first: invalid decision JSON"), "{err}");
3470 assert!(err.contains("second: empty output"), "{err}");
3471 assert!(err.contains("[roles] chatter"), "{err}");
3472 assert_eq!(state.bump_decision_attempts.len(), 2);
3473 assert_eq!(state.handovers.len(), 1);
3474 assert!(state.release_bump.is_none());
3475 let report = crate::report::run(&state);
3476 assert!(report.contains("first: invalid decision JSON"));
3477 assert!(report.contains("second: empty output"));
3478 let restored: RunState =
3479 serde_json::from_slice(&serde_json::to_vec(&state).unwrap()).unwrap();
3480 assert_eq!(restored.bump_decision_attempts.len(), 2);
3481 }
3482
3483 #[test]
3484 fn the_known_automerge_refusal_names_branch_protection() {
3485 assert!(automerge_hint(NO_RULES).contains("branch protection with required"));
3486 let other = automerge_hint("gh: network unreachable");
3487 assert!(!other.contains("branch protection"), "{other}");
3488 let body = automerge_failure_comment(NO_RULES);
3489 assert!(body.contains("enablePullRequestAutoMerge"), "{body}");
3490 assert!(body.contains("Action required"), "{body}");
3491 }
3492
3493 const CLEAN: &str = "gh pr merge --auto: GraphQL: Pull request Pull request is in clean \
3494 status (enablePullRequestAutoMerge)";
3495
3496 #[test]
3497 fn clean_status_refusal_is_matched_narrowly() {
3498 assert!(is_clean_status_refusal(CLEAN));
3499 assert!(!is_clean_status_refusal(NO_RULES));
3500 assert!(!is_clean_status_refusal("gh: network unreachable"));
3501 assert!(!is_clean_status_refusal("Pull request is in clean status"));
3502 assert!(automerge_hint(CLEAN).contains("already green"));
3503 }
3504
3505 #[test]
3506 fn the_direct_merge_argv_matches_the_land_flags() {
3507 let a = bump_merge_argv("https://github.com/o/r/pull/9", "chore: release v1.0.0");
3508 let l = land::merge_argv(9, "chore: release v1.0.0");
3509 assert_eq!(a[..2], l[..2]);
3510 assert_eq!(a[3..], l[3..]);
3511 assert_eq!(a[2], "https://github.com/o/r/pull/9");
3512 }
3513
3514 #[test]
3515 fn a_direct_merge_is_judged_by_the_forge_not_the_exit_code() {
3516 let argv = bump_merge_argv("u", "t");
3517 let merged = |o: &AutomergeOutcome| matches!(o, AutomergeOutcome::MergedDirectly { .. });
3518 assert!(merged(&resolve_direct_merge(CLEAN, &argv, true, "", None)));
3519 let detached = "not on any branch";
3520 assert!(merged(&resolve_direct_merge(
3521 CLEAN,
3522 &argv,
3523 false,
3524 detached,
3525 Some(PrLifecycle::Merged)
3526 )));
3527 for after in [Some(PrLifecycle::Open), None] {
3528 let o = resolve_direct_merge(CLEAN, &argv, false, "boom", after);
3529 match o {
3530 AutomergeOutcome::Failed { reason } => {
3531 assert!(
3532 reason.contains("clean status") && reason.contains("boom"),
3533 "{reason}"
3534 )
3535 }
3536 other => panic!("expected Failed, got {other:?}"),
3537 }
3538 }
3539 }
3540
3541 #[test]
3542 fn a_local_mode_bump_reads_back_and_old_records_are_not_local() {
3543 let old: run::ReleaseBump =
3544 serde_json::from_str(r#"{"pr_url":"u","automerge_enabled":true}"#).unwrap();
3545 assert!(!old.local);
3546 let mut state = merged_state();
3547 state.release_bump = Some(run::ReleaseBump {
3548 pr_url: Some("https://github.com/o/r/pull/9".to_owned()),
3549 version: Some("1.0.0".to_owned()),
3550 local: true,
3551 ..run::ReleaseBump::default()
3552 });
3553 assert!(!state.needs_attention());
3555 let text = crate::report::run(&state);
3556 assert!(text.contains("release.mode = local"), "{text}");
3557 assert!(!text.contains("FAILED"), "{text}");
3558 }
3559
3560 #[test]
3561 fn a_directly_merged_bump_is_not_reported_as_pending_or_failed() {
3562 let mut state = merged_state();
3563 state.release_bump = Some(run::ReleaseBump {
3564 pr_url: Some("https://github.com/o/r/pull/9".to_owned()),
3565 version: Some("1.0.0".to_owned()),
3566 merged_directly: true,
3567 ..run::ReleaseBump::default()
3568 });
3569 assert!(!state.needs_attention());
3570 let text = crate::report::run(&state);
3571 assert!(text.contains("merged directly"), "{text}");
3572 assert!(!text.contains("FAILED"), "{text}");
3573 }
3574
3575 #[test]
3576 fn an_automerge_failure_is_recorded_shown_and_filed_and_survives_settling() {
3577 let dir = tempfile::tempdir().unwrap();
3578 let store = Notices::at(dir.path().join("notifications"));
3579 let questions = ask::Questions::at(dir.path().join("questions"));
3580 let mut state = merged_state();
3581 let url = "https://github.com/o/r/pull/35";
3582
3583 let (n, comment) =
3584 surface_problem(&mut state, &store, Some(url), Some("0.8.0"), NO_RULES).unwrap();
3585
3586 let comment = comment.expect("a PR was opened, so it gets a comment");
3588 assert!(comment.contains("branch protection"), "{comment}");
3589
3590 assert_eq!(state.status, RunStatus::Merged);
3592 assert!(state.needs_attention());
3593 let text = crate::report::run(&state);
3594 assert!(text.contains("release bump"), "{text}");
3595 assert!(text.contains("FAILED"), "{text}");
3596 assert!(text.contains(url), "{text}");
3597 assert!(text.contains("action required"), "{text}");
3598 assert!(crate::report::line(&state).contains("release needs a human"));
3599
3600 assert_eq!(n.severity, Severity::Error);
3602 assert_eq!(
3603 n.link,
3604 Some(Link::Url {
3605 url: url.to_owned()
3606 })
3607 );
3608 assert_eq!(store.list().len(), 1);
3609 assert!(questions.open_for(&state.id).is_empty());
3610
3611 surface_problem(&mut state, &store, Some(url), Some("0.8.0"), NO_RULES).unwrap();
3613 let listed = store.list();
3614 assert_eq!(listed.len(), 1);
3615 assert_eq!(listed[0].count, 2);
3616 }
3617
3618 #[test]
3619 fn a_bump_that_never_ran_is_surfaced_without_a_pr_comment() {
3620 let dir = tempfile::tempdir().unwrap();
3621 let store = Notices::at(dir.path().join("notifications"));
3622 let mut state = merged_state();
3623 let (n, comment) = surface_problem(&mut state, &store, None, None, "no agent").unwrap();
3624 assert!(comment.is_none());
3625 assert!(matches!(n.link, Some(Link::Run { .. })));
3626 assert!(state.needs_attention());
3627 }
3628
3629 #[test]
3630 fn version_parses_and_bumps_each_digit() {
3631 let v = Version::parse("0.4.0").unwrap();
3632 assert_eq!(
3633 v,
3634 Version {
3635 major: 0,
3636 minor: 4,
3637 patch: 0
3638 }
3639 );
3640
3641 assert_eq!(v.bump(BumpLevel::Major).to_string(), "1.0.0");
3642 assert_eq!(v.bump(BumpLevel::Minor).to_string(), "0.5.0");
3643 assert_eq!(v.bump(BumpLevel::Patch).to_string(), "0.4.1");
3644 }
3645
3646 #[test]
3647 fn version_tolerates_a_prerelease_suffix_on_patch() {
3648 let v = Version::parse("1.2.3-rc1").unwrap();
3649 assert_eq!(
3650 v,
3651 Version {
3652 major: 1,
3653 minor: 2,
3654 patch: 3
3655 }
3656 );
3657 }
3658
3659 #[test]
3660 fn version_rejects_garbage() {
3661 assert!(Version::parse("not-a-version").is_err());
3662 assert!(Version::parse("1.2").is_err());
3663 }
3664
3665 #[test]
3666 fn decision_parses_each_level() {
3667 for (json, level) in [
3668 (
3669 r#"{"level":"major","reason":"drops a config key"}"#,
3670 BumpLevel::Major,
3671 ),
3672 (
3673 r#"{"level":"minor","reason":"adds a new flag"}"#,
3674 BumpLevel::Minor,
3675 ),
3676 (
3677 r#"{"level":"patch","reason":"fixes a race"}"#,
3678 BumpLevel::Patch,
3679 ),
3680 ] {
3681 let decision = parse_decision(json).unwrap();
3682 assert_eq!(decision.level, level);
3683 assert!(!decision.reason.is_empty());
3684 }
3685 }
3686
3687 #[test]
3688 fn decision_wrapped_in_a_fence_and_prose_still_parses() {
3689 let text = "Here is my call.\n\n```json\n{\"level\":\"minor\",\"reason\":\"new HTTP route\"}\n```\n\nDone.";
3690 let decision = parse_decision(text).unwrap();
3691 assert_eq!(decision.level, BumpLevel::Minor);
3692 assert_eq!(decision.reason, "new HTTP route");
3693 }
3694
3695 #[test]
3696 fn a_broken_reply_is_an_error_not_a_default() {
3697 assert!(parse_decision("I decline to answer.").is_err());
3698 assert!(parse_decision(r#"{"level":"huge","reason":"go big"}"#).is_err());
3699 assert!(
3700 parse_decision(r#"{"level":"patch","reason":""}"#).is_err(),
3701 "an empty reason must not pass either"
3702 );
3703 assert!(
3704 parse_decision(r#"{"level":"patch"}"#).is_err(),
3705 "a reply with no reason at all must not pass"
3706 );
3707 }
3708
3709 #[test]
3710 fn prompt_states_the_zero_x_rule_and_the_tie_break() {
3711 let prompt = decision_prompt(
3712 "feat: add a phone endpoint",
3713 "add POST /api/widgets",
3714 "1 file changed, 10 insertions(+)",
3715 &["src/web.rs".to_owned()],
3716 "0.8.0",
3717 );
3718 assert!(prompt.contains("0.8.0"), "the current version is stated");
3719 assert!(
3720 prompt.contains("below `1.0.0`")
3721 && prompt.contains("`minor` is the digit that carries a breaking change"),
3722 "the 0.x rule must be explicit: {prompt}"
3723 );
3724 assert!(
3725 prompt.contains("choose the larger"),
3726 "the tie-break toward the bigger digit must be explicit: {prompt}"
3727 );
3728 }
3729
3730 #[test]
3731 fn release_only_diffs_are_recognised() {
3732 assert!(is_release_only(&["Cargo.toml".to_owned()]));
3733 assert!(is_release_only(&[
3734 "Cargo.toml".to_owned(),
3735 "Cargo.lock".to_owned()
3736 ]));
3737 assert!(!is_release_only(&[]));
3738 assert!(!is_release_only(&[
3739 "Cargo.toml".to_owned(),
3740 "src/main.rs".to_owned()
3741 ]));
3742 }
3743
3744 #[test]
3745 fn cargo_version_rewrite_touches_only_the_package_table() {
3746 let toml = "\
3747[package]\n\
3748# a comment mentioning version on purpose\n\
3749name = \"magi-cli\"\n\
3750version = \"0.8.0\"\n\
3751edition = \"2024\"\n\
3752\n\
3753[dependencies]\n\
3754foo = { version = \"1.2.3\" }\n";
3755 let out = rewrite_cargo_version(toml, "0.9.0").unwrap();
3756 assert!(out.contains("version = \"0.9.0\""));
3757 assert!(
3758 out.contains("foo = { version = \"1.2.3\" }"),
3759 "a dependency's own version pin must survive: {out}"
3760 );
3761 assert!(
3762 out.contains("# a comment mentioning version on purpose"),
3763 "unrelated lines, comments included, must be byte-for-byte preserved: {out}"
3764 );
3765 assert_eq!(
3766 out.lines().count(),
3767 toml.lines().count(),
3768 "the rewrite replaces one line, it does not add or remove any"
3769 );
3770 }
3771
3772 #[test]
3773 fn cargo_version_rewrite_fails_without_a_package_table() {
3774 let toml = "[dependencies]\nfoo = \"1\"\n";
3775 assert!(rewrite_cargo_version(toml, "1.0.0").is_err());
3776 }
3777
3778 #[test]
3784 fn cargo_version_rewrite_falls_back_to_workspace_package_without_a_package_table() {
3785 let toml = "\
3786[workspace]\n\
3787members = [\"crates/a\", \"crates/b\"]\n\
3788\n\
3789[workspace.package]\n\
3790version = \"0.45.18\"\n\
3791edition = \"2024\"\n\
3792\n\
3793[workspace.dependencies]\n\
3794foo = { version = \"1.2.3\" }\n";
3795 let out = rewrite_cargo_version(toml, "0.45.19").unwrap();
3796 assert!(out.contains("version = \"0.45.19\""));
3797 assert!(
3798 out.contains("foo = { version = \"1.2.3\" }"),
3799 "a workspace dependency's own version pin must survive: {out}"
3800 );
3801 assert_eq!(
3802 out.lines().count(),
3803 toml.lines().count(),
3804 "the rewrite replaces one line, it does not add or remove any"
3805 );
3806 }
3807
3808 #[test]
3812 fn cargo_version_rewrite_bumps_an_internal_workspace_dependency_pin() {
3813 let toml = "\
3814[workspace]\n\
3815members = [\"crates/kanade-shared\"]\n\
3816\n\
3817[workspace.package]\n\
3818version = \"0.48.2\"\n\
3819\n\
3820[workspace.dependencies]\n\
3821kanade-shared = { path = \"crates/kanade-shared\", version = \"0.48.2\" }\n";
3822 let out = rewrite_cargo_version(toml, "0.48.3").unwrap();
3823 assert!(out.contains("[workspace.package]\nversion = \"0.48.3\"\n"));
3824 assert!(
3825 out.contains(
3826 "kanade-shared = { path = \"crates/kanade-shared\", version = \"0.48.3\" }"
3827 ),
3828 "the internal pin must move with the workspace version: {out}"
3829 );
3830 }
3831
3832 #[test]
3834 fn cargo_version_rewrite_bumps_an_internal_pin_with_version_before_path() {
3835 let toml = "\
3836[workspace.package]\n\
3837version = \"1.0.0\"\n\
3838\n\
3839[workspace.dependencies]\n\
3840inner = { version = \"1.0.0\", path = \"crates/inner\" }\n";
3841 let out = rewrite_cargo_version(toml, "1.0.1").unwrap();
3842 assert!(out.contains("inner = { version = \"1.0.1\", path = \"crates/inner\" }"));
3843 }
3844
3845 #[test]
3848 fn cargo_version_rewrite_bumps_an_internal_pin_in_dotted_table_form() {
3849 let toml = "\
3850[workspace.package]\n\
3851version = \"2.3.0\"\n\
3852\n\
3853[workspace.dependencies.inner]\n\
3854path = \"crates/inner\"\n\
3855version = \"2.3.0\"\n";
3856 let out = rewrite_cargo_version(toml, "2.4.0").unwrap();
3857 assert!(out.contains("[workspace.package]\nversion = \"2.4.0\"\n"));
3858 assert!(out.contains(
3859 "[workspace.dependencies.inner]\npath = \"crates/inner\"\nversion = \"2.4.0\"\n"
3860 ));
3861 }
3862
3863 #[test]
3868 fn cargo_version_rewrite_bumps_an_internal_pin_in_dotted_key_form() {
3869 let toml = "\
3870[workspace.package]\n\
3871version = \"2.3.0\"\n\
3872\n\
3873[workspace.dependencies]\n\
3874inner.path = \"crates/inner\"\n\
3875inner.version = \"2.3.0\"\n";
3876 let out = rewrite_cargo_version(toml, "2.4.0").unwrap();
3877 assert!(out.contains("[workspace.package]\nversion = \"2.4.0\"\n"));
3878 assert!(out.contains("inner.path = \"crates/inner\"\ninner.version = \"2.4.0\"\n"));
3879 }
3880
3881 #[test]
3884 fn cargo_version_rewrite_leaves_a_path_only_workspace_dependency_untouched() {
3885 let toml = "\
3886[workspace.package]\n\
3887version = \"0.1.0\"\n\
3888\n\
3889[workspace.dependencies]\n\
3890internal-only = { path = \"crates/internal-only\" }\n";
3891 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
3892 assert!(out.contains("internal-only = { path = \"crates/internal-only\" }"));
3893 }
3894
3895 #[test]
3899 fn cargo_version_rewrite_leaves_an_external_dependency_untouched() {
3900 let toml = "\
3901[workspace.package]\n\
3902version = \"0.1.0\"\n\
3903\n\
3904[workspace.dependencies]\n\
3905serde = { version = \"1\", features = [\"derive\"] }\n\
3906inner = { path = \"crates/inner\", version = \"0.1.0\" }\n";
3907 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
3908 assert!(out.contains("serde = { version = \"1\", features = [\"derive\"] }"));
3909 assert!(out.contains("inner = { path = \"crates/inner\", version = \"0.2.0\" }"));
3910 }
3911
3912 #[test]
3916 fn cargo_version_rewrite_without_workspace_dependencies_table_still_bumps_package() {
3917 let toml = "[workspace.package]\nversion = \"0.9.0\"\nedition = \"2024\"\n";
3918 let out = rewrite_cargo_version(toml, "0.10.0").unwrap();
3919 assert_eq!(
3920 out,
3921 "[workspace.package]\nversion = \"0.10.0\"\nedition = \"2024\"\n"
3922 );
3923 }
3924
3925 #[test]
3928 fn cargo_version_rewrite_handles_a_kanade_shaped_workspace_dependencies_table() {
3929 let toml = "\
3930[workspace.package]\n\
3931version = \"0.48.2\"\n\
3932\n\
3933[workspace.dependencies]\n\
3934anyhow = { version = \"1\" }\n\
3935serde = { version = \"1\", features = [\"derive\"] }\n\
3936kanade-shared = { path = \"crates/kanade-shared\", version = \"0.48.2\" }\n\
3937kanade-core = { path = \"crates/kanade-core\", version = \"0.48.2\" }\n\
3938kanade-internal-tool = { path = \"crates/kanade-internal-tool\" }\n";
3939 let out = rewrite_cargo_version(toml, "0.48.3").unwrap();
3940 assert!(out.contains("anyhow = { version = \"1\" }"));
3941 assert!(out.contains("serde = { version = \"1\", features = [\"derive\"] }"));
3942 assert!(
3943 out.contains(
3944 "kanade-shared = { path = \"crates/kanade-shared\", version = \"0.48.3\" }"
3945 )
3946 );
3947 assert!(
3948 out.contains("kanade-core = { path = \"crates/kanade-core\", version = \"0.48.3\" }")
3949 );
3950 assert!(out.contains("kanade-internal-tool = { path = \"crates/kanade-internal-tool\" }"));
3951 }
3952
3953 #[test]
3957 fn cargo_version_rewrite_bails_on_an_unrepresentable_inline_table() {
3958 let toml = "\
3959[workspace.package]\n\
3960version = \"0.1.0\"\n\
3961\n\
3962[workspace.dependencies]\n\
3963inner = { path = \"crates/inner\",\n\
3964 version = \"0.1.0\" }\n";
3965 assert!(rewrite_cargo_version(toml, "0.2.0").is_err());
3966 }
3967
3968 #[test]
3971 fn cargo_version_rewrite_recognises_a_commented_workspace_dependencies_header() {
3972 let toml = "\
3973[workspace.package]\n\
3974version = \"0.1.0\"\n\
3975\n\
3976[workspace.dependencies] # internal pins\n\
3977inner = { path = \"crates/inner\", version = \"0.1.0\" }\n";
3978 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
3979 assert!(out.contains("inner = { path = \"crates/inner\", version = \"0.2.0\" }"));
3980 }
3981
3982 #[test]
3985 fn cargo_version_rewrite_bumps_a_quoted_dependency_key() {
3986 let toml = "\
3987[workspace.package]\n\
3988version = \"0.1.0\"\n\
3989\n\
3990[workspace.dependencies]\n\
3991\"inner\" = { path = \"crates/inner\", version = \"0.1.0\" }\n";
3992 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
3993 assert!(out.contains("\"inner\" = { path = \"crates/inner\", version = \"0.2.0\" }"));
3994 }
3995
3996 #[test]
4000 fn cargo_version_rewrite_bumps_a_literal_string_version_pin() {
4001 let toml = "\
4002[workspace.package]\n\
4003version = \"0.1.0\"\n\
4004\n\
4005[workspace.dependencies]\n\
4006inner = { path = 'crates/inner', version = '0.1.0' }\n";
4007 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
4008 assert!(out.contains("inner = { path = 'crates/inner', version = '0.2.0' }"));
4009 }
4010
4011 #[test]
4017 fn cargo_version_rewrite_does_not_require_the_whole_file_to_parse() {
4018 let toml = "\
4019[workspace.package]\n\
4020version = \"0.1.0\"\n\
4021\n\
4022[workspace.dependencies]\n\
4023inner = { path = \"crates/inner\", version = \"0.1.0\" }\n\
4024\n\
4025[workspace.package]\n\
4026edition = \"2024\"\n";
4027 let out = rewrite_cargo_version(toml, "0.2.0").unwrap();
4028 assert!(out.contains("inner = { path = \"crates/inner\", version = \"0.2.0\" }"));
4029 assert!(
4030 toml::from_str::<toml::Value>(toml).is_err(),
4031 "the fixture itself must be invalid as a whole file, or this test proves nothing"
4032 );
4033 }
4034
4035 #[test]
4036 fn current_version_prefers_the_package_table_when_both_exist() {
4037 let toml = "[workspace.package]\nversion = \"9.9.9\"\n\n[package]\nversion = \"0.8.0\"\n";
4038 assert_eq!(current_version(toml).unwrap(), "0.8.0");
4039 }
4040
4041 #[test]
4044 fn current_version_falls_back_to_workspace_package_without_a_package_table() {
4045 let toml = "\
4046[workspace]\n\
4047members = [\"crates/a\", \"crates/b\"]\n\
4048\n\
4049[workspace.package]\n\
4050version = \"0.45.18\"\n";
4051 assert_eq!(current_version(toml).unwrap(), "0.45.18");
4052 }
4053
4054 #[test]
4055 fn coalesce_proceeds_with_nothing_pending() {
4056 assert_eq!(coalesce(None, "0.8.0").unwrap(), Coalesce::Proceed);
4057 }
4058
4059 fn test_pending(target_version: &str, level: BumpLevel) -> PendingBump {
4062 PendingBump {
4063 target_version: target_version.to_owned(),
4064 level,
4065 branch: format!("chore/release-v{target_version}"),
4066 pr_url: "https://example.invalid/pull/9".to_owned(),
4067 }
4068 }
4069
4070 #[test]
4071 fn coalesce_skips_while_the_pending_target_is_still_ahead() {
4072 let pending = test_pending("0.9.0", BumpLevel::Minor);
4073 assert_eq!(
4074 coalesce(Some(&pending), "0.8.0").unwrap(),
4075 Coalesce::Skip {
4076 target_version: "0.9.0".to_owned()
4077 }
4078 );
4079 }
4080
4081 #[test]
4082 fn coalesce_treats_a_landed_or_superseded_pending_bump_as_stale() {
4083 let pending = test_pending("0.9.0", BumpLevel::Minor);
4084 assert_eq!(
4086 coalesce(Some(&pending), "0.9.0").unwrap(),
4087 Coalesce::Proceed
4088 );
4089 assert_eq!(
4091 coalesce(Some(&pending), "1.0.0").unwrap(),
4092 Coalesce::Proceed
4093 );
4094 }
4095
4096 #[test]
4097 fn pending_action_escalates_only_for_a_more_severe_decision() {
4098 assert_eq!(
4099 pending_action(BumpLevel::Patch, BumpLevel::Patch),
4100 PendingAction::AlreadyCovered
4101 );
4102 assert_eq!(
4103 pending_action(BumpLevel::Patch, BumpLevel::Minor),
4104 PendingAction::Escalate
4105 );
4106 assert_eq!(
4107 pending_action(BumpLevel::Patch, BumpLevel::Major),
4108 PendingAction::Escalate
4109 );
4110 assert_eq!(
4111 pending_action(BumpLevel::Minor, BumpLevel::Patch),
4112 PendingAction::AlreadyCovered
4113 );
4114 assert_eq!(
4115 pending_action(BumpLevel::Major, BumpLevel::Minor),
4116 PendingAction::AlreadyCovered
4117 );
4118 assert_eq!(
4119 pending_action(BumpLevel::Major, BumpLevel::Major),
4120 PendingAction::AlreadyCovered
4121 );
4122 }
4123
4124 #[test]
4125 fn pr_state_parsing_reads_open_and_not_open() {
4126 assert!(parse_pr_state(r#"{"state":"OPEN"}"#).unwrap());
4127 assert!(!parse_pr_state(r#"{"state":"CLOSED"}"#).unwrap());
4128 assert!(!parse_pr_state(r#"{"state":"MERGED"}"#).unwrap());
4129 }
4130
4131 #[test]
4132 fn a_lock_is_exclusive_until_dropped() {
4133 let dir = tempfile::tempdir().unwrap();
4134 let marker = dir.path().join("bump").join("deadbeefdeadbeef.json");
4135 let first = MarkerLock::acquire(&marker)
4136 .unwrap()
4137 .expect("first attempt takes the lock");
4138 assert!(
4139 MarkerLock::acquire(&marker).unwrap().is_none(),
4140 "a second attempt must be refused while the first holds it"
4141 );
4142 drop(first);
4143 assert!(
4144 MarkerLock::acquire(&marker).unwrap().is_some(),
4145 "dropping the guard releases the lock for the next attempt"
4146 );
4147 }
4148
4149 #[test]
4150 fn a_stale_lock_is_reclaimed() {
4151 let dir = tempfile::tempdir().unwrap();
4152 let marker = dir.path().join("bump").join("deadbeefdeadbeef.json");
4153 let lock_path = marker.with_extension("lock");
4154 std::fs::create_dir_all(lock_path.parent().unwrap()).unwrap();
4155 std::fs::write(&lock_path, b"").unwrap();
4156 let old = std::time::SystemTime::now() - LOCK_STALE_AFTER - Duration::from_secs(1);
4157 std::fs::OpenOptions::new()
4158 .write(true)
4159 .open(&lock_path)
4160 .unwrap()
4161 .set_modified(old)
4162 .unwrap();
4163 assert!(
4164 MarkerLock::acquire(&marker).unwrap().is_some(),
4165 "a lock older than the stale window must be reclaimed rather than block forever"
4166 );
4167 }
4168
4169 #[tokio::test]
4170 async fn a_contended_lock_is_retried_until_the_holder_releases_it() {
4171 let dir = tempfile::tempdir().unwrap();
4172 let marker = dir.path().join("bump").join("deadbeefdeadbeef.json");
4173 let held = MarkerLock::acquire(&marker)
4174 .unwrap()
4175 .expect("seed the contention");
4176 let releaser = tokio::spawn(async move {
4177 tokio::time::sleep(Duration::from_millis(20)).await;
4178 drop(held);
4179 });
4180 let waited =
4181 wait_for_marker_lock_with(&marker, Duration::from_millis(5), Duration::from_secs(5))
4182 .await
4183 .unwrap();
4184 assert!(
4185 waited.is_some(),
4186 "a merge landing behind another's still-running decision must not be dropped - it \
4187 must wait for that decision to finish and then judge against what it left behind"
4188 );
4189 releaser.await.unwrap();
4190 }
4191
4192 #[tokio::test]
4193 async fn a_lock_held_past_the_ceiling_gives_up() {
4194 let dir = tempfile::tempdir().unwrap();
4195 let marker = dir.path().join("bump").join("deadbeefdeadbeef.json");
4196 let _held = MarkerLock::acquire(&marker).unwrap().unwrap();
4197 let waited =
4198 wait_for_marker_lock_with(&marker, Duration::from_millis(2), Duration::from_millis(10))
4199 .await
4200 .unwrap();
4201 assert!(
4202 waited.is_none(),
4203 "a lock genuinely held past the ceiling must eventually give up rather than wait \
4204 forever"
4205 );
4206 }
4207
4208 #[test]
4209 fn level_between_reads_off_the_differing_digit() {
4210 assert_eq!(
4211 level_between(
4212 Version::parse("0.8.0").unwrap(),
4213 Version::parse("1.0.0").unwrap()
4214 ),
4215 Some(BumpLevel::Major)
4216 );
4217 assert_eq!(
4218 level_between(
4219 Version::parse("0.8.0").unwrap(),
4220 Version::parse("0.9.0").unwrap()
4221 ),
4222 Some(BumpLevel::Minor)
4223 );
4224 assert_eq!(
4225 level_between(
4226 Version::parse("0.8.0").unwrap(),
4227 Version::parse("0.8.1").unwrap()
4228 ),
4229 Some(BumpLevel::Patch)
4230 );
4231 assert_eq!(
4232 level_between(
4233 Version::parse("0.8.0").unwrap(),
4234 Version::parse("0.8.0").unwrap()
4235 ),
4236 None
4237 );
4238 }
4239
4240 #[test]
4241 fn open_release_pr_is_found_among_unrelated_pull_requests() {
4242 let json = r#"[
4243 {"url": "https://example.invalid/pull/1", "headRefName": "feat/something"},
4244 {"url": "https://example.invalid/pull/2", "headRefName": "chore/release-v0.9.0"}
4245 ]"#;
4246 let found = parse_open_release_pr(json).unwrap();
4247 assert_eq!(
4248 found,
4249 Some((
4250 "chore/release-v0.9.0".to_owned(),
4251 "https://example.invalid/pull/2".to_owned()
4252 ))
4253 );
4254 }
4255
4256 #[test]
4257 fn no_open_release_pr_reads_as_none_not_an_error() {
4258 let json =
4259 r#"[{"url": "https://example.invalid/pull/1", "headRefName": "feat/something"}]"#;
4260 assert_eq!(parse_open_release_pr(json).unwrap(), None);
4261 assert_eq!(parse_open_release_pr("[]").unwrap(), None);
4262 }
4263
4264 #[test]
4265 fn marker_round_trips_through_disk() {
4266 let dir = tempfile::tempdir().unwrap();
4267 let path = marker_path(dir.path(), Path::new("/repos/magi"));
4268 assert!(read_marker(&path).is_none());
4269
4270 let marker = test_pending("0.9.0", BumpLevel::Patch);
4271 write_marker(&path, &marker).unwrap();
4272 let read_back = read_marker(&path).unwrap();
4273 assert_eq!(read_back.target_version, "0.9.0");
4274 assert_eq!(read_back.level, BumpLevel::Patch);
4275 assert_eq!(read_back.pr_url, marker.pr_url);
4276
4277 clear_marker(&path);
4278 assert!(read_marker(&path).is_none());
4279 }
4280
4281 #[test]
4282 fn different_repos_get_different_marker_files() {
4283 let dir = tempfile::tempdir().unwrap();
4284 let a = marker_path(dir.path(), Path::new("/repos/a"));
4285 let b = marker_path(dir.path(), Path::new("/repos/b"));
4286 assert_ne!(a, b);
4287 }
4288
4289 #[test]
4293 fn a_bump_pull_requests_own_merge_does_not_retrigger() {
4294 let files = vec!["Cargo.toml".to_owned(), "Cargo.lock".to_owned()];
4295 assert!(
4296 is_release_only(&files),
4297 "the bump pull request's own diff must read as release-only"
4298 );
4299 }
4300
4301 #[test]
4302 fn should_release_bump_reads_only_a_merged_status() {
4303 assert!(should_release_bump(RunStatus::Merged));
4304 for other in [RunStatus::Blocked, RunStatus::Ready, RunStatus::Prep] {
4305 assert!(!should_release_bump(other));
4306 }
4307 }
4308
4309 #[test]
4313 fn all_three_merge_paths_report_pr_lifecycle_merged_case_done() {
4314 let pr = land::PrState {
4315 url: "https://github.com/o/r/pull/1".to_owned(),
4316 number: 1,
4317 state: PrLifecycle::Merged,
4318 checks: land::Checks::Green,
4319 failing: Vec::new(),
4320 review_comments: Vec::new(),
4321 blocking: land::Blocking::No,
4322 };
4323 assert_eq!(
4324 land::decide(&pr, 0, 4, Duration::ZERO),
4325 land::Step::Done { merged: true }
4326 );
4327 assert!(should_release_bump(RunStatus::Merged));
4328 }
4329
4330 #[test]
4335 fn all_three_merge_paths_report_pr_lifecycle_merged_case_direct_merge() {
4336 let pr = land::PrState {
4337 url: "https://github.com/o/r/pull/2".to_owned(),
4338 number: 2,
4339 state: PrLifecycle::Open,
4340 checks: land::Checks::Green,
4341 failing: Vec::new(),
4342 review_comments: Vec::new(),
4343 blocking: land::Blocking::No,
4344 };
4345 assert_eq!(land::decide(&pr, 0, 4, Duration::ZERO), land::Step::Merge);
4346 assert!(should_release_bump(RunStatus::Merged));
4349 }
4350
4351 #[test]
4354 fn all_three_merge_paths_report_pr_lifecycle_merged_case_merged_after_all() {
4355 let argv = land::merge_argv(3, "feat: something");
4356 let outcome = land::merged_after_all(
4357 &argv,
4358 "could not determine current branch: not on any branch",
4359 Some(PrLifecycle::Merged),
4360 );
4361 assert!(outcome.is_some(), "the forge's confirmation must win");
4362 assert!(should_release_bump(RunStatus::Merged));
4363
4364 assert!(land::merged_after_all(&argv, "network error", Some(PrLifecycle::Open)).is_none());
4367 assert!(land::merged_after_all(&argv, "network error", None).is_none());
4368 }
4369
4370 #[test]
4372 fn a_close_or_a_give_up_does_not_trigger_a_bump() {
4373 let pr = land::PrState {
4374 url: "https://github.com/o/r/pull/4".to_owned(),
4375 number: 4,
4376 state: PrLifecycle::Closed,
4377 checks: land::Checks::Green,
4378 failing: Vec::new(),
4379 review_comments: Vec::new(),
4380 blocking: land::Blocking::No,
4381 };
4382 assert_eq!(
4383 land::decide(&pr, 0, 4, Duration::ZERO),
4384 land::Step::Done { merged: false }
4385 );
4386 assert!(!should_release_bump(RunStatus::Blocked));
4387 }
4388
4389 fn shun_files() -> Vec<crate::config::VersionFile> {
4390 use crate::config::{VersionFile, VersionKind};
4391 vec![
4392 VersionFile {
4393 path: "src-tauri/Cargo.toml".to_owned(),
4394 kind: VersionKind::Cargo,
4395 },
4396 VersionFile {
4397 path: "package.json".to_owned(),
4398 kind: VersionKind::Json,
4399 },
4400 VersionFile {
4401 path: "src-tauri/tauri.conf.json".to_owned(),
4402 kind: VersionKind::Json,
4403 },
4404 ]
4405 }
4406
4407 const SHUN_TOML: &str = "[package]\nname = \"shun\"\nversion = \"1.0.0\"\n";
4408 const SHUN_LOCK: &str = "[[package]]\nname = \"shun\"\nversion = \"1.0.0\"\n";
4409
4410 async fn shun_origin(package_version: &str) -> (tempfile::TempDir, PathBuf) {
4411 let pkg = format!("{{\n \"version\": \"{package_version}\"\n}}\n");
4412 let origin = origin_with(&[("README.md", "x\n")]).await;
4413 for (name, body) in [
4414 ("src-tauri/Cargo.toml", SHUN_TOML),
4415 ("src-tauri/Cargo.lock", SHUN_LOCK),
4416 ("package.json", pkg.as_str()),
4417 ("src-tauri/tauri.conf.json", "{ \"version\": \"1.0.0\" }\n"),
4418 ] {
4419 let path = origin.1.join(name);
4420 tokio::fs::create_dir_all(path.parent().unwrap())
4421 .await
4422 .unwrap();
4423 tokio::fs::write(path, body).await.unwrap();
4424 }
4425 git::git(&origin.1, &["add", "-A"]).await.unwrap();
4426 git::git(&origin.1, &["commit", "-m", "shun"])
4427 .await
4428 .unwrap();
4429 git::git(&origin.1, &["push", "origin", "main"])
4430 .await
4431 .unwrap();
4432 origin
4433 }
4434
4435 #[tokio::test]
4436 async fn a_shun_layout_bump_changes_only_the_declared_files_and_the_adjacent_lock() {
4437 let (_d, repo) = shun_origin("1.0.0").await;
4438 let mut state = winner_state(&repo, "main");
4439 state.config.release.version_files = shun_files();
4440 write_release_files(&state, &repo, "1.1.0").await.unwrap();
4441 let status = git::git(&repo, &["status", "--porcelain"]).await.unwrap();
4442 let mut paths: Vec<_> = status.lines().map(|l| l[3..].to_owned()).collect();
4443 paths.sort();
4444 assert_eq!(
4445 paths,
4446 [
4447 "package.json",
4448 "src-tauri/Cargo.lock",
4449 "src-tauri/Cargo.toml",
4450 "src-tauri/tauri.conf.json"
4451 ]
4452 );
4453 let lock = std::fs::read_to_string(repo.join("src-tauri/Cargo.lock")).unwrap();
4454 assert!(lock.contains("version = \"1.1.0\""));
4455 }
4456
4457 #[tokio::test]
4458 async fn an_unconfigured_repo_with_auto_tag_but_no_root_manifest_is_skipped_visibly() {
4459 let (_d, repo) = origin_with(&[("README.md", "x\n")]).await;
4460 let wf = repo.join(".github/workflows");
4461 tokio::fs::create_dir_all(&wf).await.unwrap();
4462 tokio::fs::write(wf.join("auto-tag.yml"), "name: t\n")
4463 .await
4464 .unwrap();
4465 git::git(&repo, &["add", "-A"]).await.unwrap();
4466 git::git(&repo, &["commit", "-m", "wf"]).await.unwrap();
4467 git::git(&repo, &["push", "origin", "main"]).await.unwrap();
4468 let home = tempfile::tempdir().unwrap();
4469 let store = Notices::at(home.path().join("notifications"));
4470 let mut state = winner_state(&repo, "main");
4471 after_merge_at(
4472 &mut state,
4473 "https://example.invalid/pull/1",
4474 Some(home.path()),
4475 Some(&store),
4476 )
4477 .await
4478 .unwrap();
4479 let rec = state.release_bump.clone().expect("a skip is recorded");
4480 assert!(rec.skipped.is_some_and(|s| s.contains("Cargo.toml")));
4481 assert!(
4482 rec.action_required
4483 .is_some_and(|a| a.contains("version_files"))
4484 );
4485 assert!(rec.pr_url.is_none() && !rec.automerge_enabled);
4486 assert_eq!(store.list().len(), 1);
4487 assert!(crate::report::run(&state).contains("SKIPPED"));
4488 }
4489
4490 #[tokio::test]
4491 async fn a_non_rust_repo_without_auto_tag_records_a_skip_without_paging() {
4492 let (_d, repo) = origin_with(&[("README.md", "hi\n")]).await;
4493 let home = tempfile::tempdir().unwrap();
4494 let store = Notices::at(home.path().join("notifications"));
4495 let mut state = winner_state(&repo, "main");
4496 after_merge_at(
4497 &mut state,
4498 "https://example.invalid/pull/1",
4499 Some(home.path()),
4500 Some(&store),
4501 )
4502 .await
4503 .unwrap();
4504 let rec = state.release_bump.clone().unwrap();
4505 assert!(rec.skipped.is_some());
4506 assert!(rec.action_required.is_none());
4507 assert!(store.list().is_empty());
4508 }
4509
4510 #[tokio::test]
4511 async fn disagreeing_version_files_stop_the_bump_and_ask_the_owner() {
4512 let (_d, repo) = shun_origin("0.9.0").await;
4513 let home = tempfile::tempdir().unwrap();
4514 let store = Notices::at(home.path().join("notifications"));
4515 let mut state = winner_state(&repo, "main");
4516 state.config.release.version_files = shun_files();
4517 after_merge_at(
4518 &mut state,
4519 "https://example.invalid/pull/1",
4520 Some(home.path()),
4521 Some(&store),
4522 )
4523 .await
4524 .unwrap();
4525 let rec = state.release_bump.clone().unwrap();
4526 assert!(rec.skipped.is_some_and(|s| s.contains("disagree")));
4527 assert!(rec.action_required.is_some());
4528 assert_eq!(store.list().len(), 1);
4529 assert!(rec.pr_url.is_none());
4530 }
4531
4532 #[tokio::test]
4533 async fn a_change_that_already_raised_the_version_is_left_to_the_repos_auto_tag() {
4534 let (_d, repo) = shun_origin("1.0.0").await;
4535 git::git(&repo, &["checkout", "-b", "feat"]).await.unwrap();
4536 let toml = SHUN_TOML.replace("1.0.0", "1.0.1");
4537 tokio::fs::write(repo.join("src-tauri/Cargo.toml"), toml)
4538 .await
4539 .unwrap();
4540 tokio::fs::write(repo.join("app.ts"), "x\n").await.unwrap();
4541 git::git(&repo, &["add", "-A"]).await.unwrap();
4542 git::git(&repo, &["commit", "-m", "fix and bump"])
4543 .await
4544 .unwrap();
4545 let home = tempfile::tempdir().unwrap();
4546 let store = Notices::at(home.path().join("notifications"));
4547 let mut state = winner_state(&repo, "main");
4548 state.candidates[0].branch = "feat".to_owned();
4549 state.config.release.version_files = shun_files();
4550 after_merge_at(
4551 &mut state,
4552 "https://example.invalid/pull/1",
4553 Some(home.path()),
4554 Some(&store),
4555 )
4556 .await
4557 .unwrap();
4558 let rec = state.release_bump.clone().unwrap();
4559 assert!(
4560 rec.skipped
4561 .is_some_and(|s| s.contains("already") || s.contains("raised"))
4562 );
4563 assert!(rec.pr_url.is_none() && rec.action_required.is_none());
4564 assert!(store.list().is_empty());
4565 }
4566
4567 #[tokio::test]
4568 async fn a_stale_local_base_does_not_make_an_inherited_version_look_like_this_changes() {
4569 let (_d, repo) = shun_origin("1.0.0").await;
4570 let old = git::rev_parse(&repo, "HEAD").await.unwrap();
4571 tokio::fs::write(
4572 repo.join("src-tauri/Cargo.toml"),
4573 SHUN_TOML.replace("1.0.0", "1.0.1"),
4574 )
4575 .await
4576 .unwrap();
4577 git::git(&repo, &["commit", "-am", "bump upstream"])
4578 .await
4579 .unwrap();
4580 git::git(&repo, &["push", "origin", "main"]).await.unwrap();
4581 git::git(&repo, &["checkout", "-b", "feat"]).await.unwrap();
4582 tokio::fs::write(repo.join("app.ts"), "x\n").await.unwrap();
4583 git::git(&repo, &["add", "-A"]).await.unwrap();
4584 git::git(&repo, &["commit", "-m", "fix"]).await.unwrap();
4585 git::git(&repo, &["update-ref", "refs/heads/main", &old])
4587 .await
4588 .unwrap();
4589 let home = tempfile::tempdir().unwrap();
4590 let store = Notices::at(home.path().join("notifications"));
4591 let mut state = winner_state(&repo, "main");
4592 state.candidates[0].branch = "feat".to_owned();
4593 state.config.release.version_files = shun_files();
4594 let _ = after_merge_at(
4595 &mut state,
4596 "https://example.invalid/pull/1",
4597 Some(home.path()),
4598 Some(&store),
4599 )
4600 .await;
4601 assert!(
4602 !state
4603 .events
4604 .iter()
4605 .any(|e| e.message.contains("already moved")),
4606 "{:?}",
4607 state.events
4608 );
4609 }
4610
4611 #[tokio::test]
4612 async fn a_dependency_only_change_on_a_stale_local_base_is_not_release_only() {
4613 let (_d, repo) = shun_origin("1.0.0").await;
4614 let old = git::rev_parse(&repo, "HEAD").await.unwrap();
4615 for (p, from) in [
4616 ("src-tauri/Cargo.toml", SHUN_TOML),
4617 ("package.json", "{\n \"version\": \"1.0.0\"\n}\n"),
4618 ("src-tauri/tauri.conf.json", "{ \"version\": \"1.0.0\" }\n"),
4619 ] {
4620 tokio::fs::write(repo.join(p), from.replace("1.0.0", "1.0.1"))
4621 .await
4622 .unwrap();
4623 }
4624 tokio::fs::write(
4625 repo.join("src-tauri/Cargo.lock"),
4626 SHUN_LOCK.replace("1.0.0", "1.0.1"),
4627 )
4628 .await
4629 .unwrap();
4630 git::git(&repo, &["commit", "-am", "bump upstream"])
4631 .await
4632 .unwrap();
4633 git::git(&repo, &["push", "origin", "main"]).await.unwrap();
4634 git::git(&repo, &["checkout", "-b", "feat"]).await.unwrap();
4635 tokio::fs::write(
4636 repo.join("package.json"),
4637 "{\n \"version\": \"1.0.1\",\n \"dependencies\": {}\n}\n",
4638 )
4639 .await
4640 .unwrap();
4641 git::git(&repo, &["commit", "-am", "deps"]).await.unwrap();
4642 git::git(&repo, &["update-ref", "refs/heads/main", &old])
4643 .await
4644 .unwrap();
4645 let home = tempfile::tempdir().unwrap();
4646 let store = Notices::at(home.path().join("notifications"));
4647 let mut state = winner_state(&repo, "main");
4648 state.candidates[0].branch = "feat".to_owned();
4649 state.config.release.version_files = shun_files();
4650 let _ = after_merge_at(
4651 &mut state,
4652 "https://example.invalid/pull/1",
4653 Some(home.path()),
4654 Some(&store),
4655 )
4656 .await;
4657 assert!(
4658 !state
4659 .events
4660 .iter()
4661 .any(|e| e.message.contains("only the release manifest")),
4662 "{:?}",
4663 state.events
4664 );
4665 assert!(
4666 state
4667 .release_bump
4668 .as_ref()
4669 .is_none_or(|b| b.skipped.is_none())
4670 );
4671 }
4672}