//! Versions, tags and releases of factory repositories. //! //! Every merged factory issue gets a version (`MAJOR.MINOR.PATCH`): the patch number goes up with each //! issue, the minor number when the issue completes a milestone (`M1.3` was the last open `M1.x` //! issue); the patch restarts at 0. A version is a commit with a `VERSION` file on the default branch //! plus the tag `vX.Y.Z` on it. Major versions are only made by a manual release, which also builds //! the Docker image and the downloads described in `.factory/release.json`. use crate::app::App; use crate::factory::{Forge, RepoCfg, bot_comment, checkout, git, issue_no, notify}; use crate::store::User; use anyhow::{Context, Result, bail}; use serde::Deserialize; use serde_json::{Value, json}; use std::collections::{HashMap, HashSet}; use std::path::{Path, PathBuf}; use std::sync::{Arc, Mutex, OnceLock}; use std::time::Duration; pub type Ver = (u64, u64, u64); pub fn parse_version(s: &str) -> Option { let mut it = s.trim().trim_start_matches('v').split('.'); let v = (it.next()?.parse().ok()?, it.next()?.parse().ok()?, it.next()?.parse().ok()?); it.next().is_none().then_some(v) } pub fn fmt(v: Ver) -> String { format!("{}.{}.{}", v.0, v.1, v.2) } /// Milestone of an issue title: `M1.3 – x` → (1, Some(3)), `M1 – x` → (1, None). pub fn milestone_of(title: &str) -> Option<(u64, Option)> { let t = title.trim(); let rest = t.strip_prefix('M').or_else(|| t.strip_prefix('m'))?; let digits: String = rest.chars().take_while(|c| c.is_ascii_digit()).collect(); let k: u64 = digits.parse().ok()?; let after = &rest[digits.len()..]; if let Some(a) = after.strip_prefix('.') { let d: String = a.chars().take_while(|c| c.is_ascii_digit()).collect(); if !d.is_empty() { return Some((k, Some(d.parse().ok()?))); } } match after.chars().next() { None | Some(' ') | Some('–') | Some('-') | Some(':') => Some((k, None)), _ => None, } } #[derive(Debug, PartialEq, Clone, Copy)] pub enum Bump { Patch, Minor, } /// How an issue raises the version, given the titles of the *other* open issues of the repository. pub fn bump_for(title: &str, other_open: &[String]) -> Bump { match milestone_of(title) { Some((_, None)) => Bump::Minor, Some((k, Some(_))) => { if other_open.iter().any(|t| matches!(milestone_of(t), Some((k2, Some(_))) if k2 == k)) { Bump::Patch } else { Bump::Minor } } None => Bump::Patch, } } pub fn next_version(cur: Ver, b: Bump) -> Ver { match b { Bump::Patch => (cur.0, cur.1, cur.2 + 1), Bump::Minor => (cur.0, cur.1 + 1, 0), } } // --- git helpers --------------------------------------------------------------------------- /// Highest `vX.Y.Z` tag of the remote (0.0.0 when there is none). async fn tags_version(cfg: &RepoCfg, dir: &Path) -> Ver { // The remote is the truth: a local checkout keeps tags that were deleted on the forge. let remote = git(cfg, dir, &["ls-remote", "--tags", "--refs", "origin", "v[0-9]*"]).await; let names: Vec = match remote { Ok(out) => out.lines().filter_map(|l| l.split("refs/tags/").nth(1)).map(str::to_string).collect(), Err(_) => { let _ = git(cfg, dir, &["fetch", "--tags", "--force", "origin"]).await; git(cfg, dir, &["tag", "-l", "v[0-9]*"]).await.unwrap_or_default().lines().map(str::to_string).collect() } }; names.iter().filter_map(|t| parse_version(t)).max().unwrap_or((0, 0, 0)) } /// `git pull --ff-only` of the default branch in the main checkout, so everything that was merged /// (also by others) is on disk for the reviews. Does nothing harmful: with local changes or a /// diverged branch it reports an error and leaves the checkout alone. pub async fn sync_default(cfg: &RepoCfg, dir: &Path) -> Result<()> { let base = base_branch(cfg, dir).await; let current = git(cfg, dir, &["rev-parse", "--abbrev-ref", "HEAD"]).await.unwrap_or_default(); if current != base { if !git(cfg, dir, &["status", "--porcelain"]).await.unwrap_or_default().is_empty() { bail!("the checkout has local changes and is on '{current}', not on {base}"); } git(cfg, dir, &["checkout", "-q", &base]).await?; } git(cfg, dir, &["merge", "--ff-only", "-q", &format!("origin/{base}")]).await?; Ok(()) } async fn base_branch(cfg: &RepoCfg, repo: &Path) -> String { git(cfg, repo, &["symbolic-ref", "--short", "refs/remotes/origin/HEAD"]).await.ok().and_then(|s| s.strip_prefix("origin/").map(String::from)).unwrap_or_else(|| "main".to_string()) } /// A throw-away detached worktree of the default branch below `//`. async fn fresh_worktree(cfg: &RepoCfg, repo: &Path, sub: &str, name: &str, base: &str) -> Result { let work = repo.parent().context("no parent folder")?.join(sub).join(name); std::fs::create_dir_all(work.parent().unwrap())?; if work.exists() { let _ = git(cfg, repo, &["worktree", "remove", "--force", &work.display().to_string()]).await; let _ = std::fs::remove_dir_all(&work); } let _ = git(cfg, repo, &["worktree", "prune"]).await; git(cfg, repo, &["worktree", "add", "--detach", &work.display().to_string(), &format!("origin/{base}")]).await?; Ok(work) } async fn drop_worktree(cfg: &RepoCfg, repo: &Path, work: &Path) { let _ = git(cfg, repo, &["worktree", "remove", "--force", &work.display().to_string()]).await; let _ = std::fs::remove_dir_all(work); } const IDENT: [&str; 4] = ["-c", "user.name=CodeCraft Factory", "-c", "user.email=factory@codecraft.invalid"]; /// Write `VERSION` and commit it locally (nothing is pushed yet). async fn commit_version(cfg: &RepoCfg, work: &Path, ver: &str, msg: &str) -> Result<()> { std::fs::write(work.join("VERSION"), format!("{ver}\n"))?; git(cfg, work, &["add", "VERSION"]).await?; if !git(cfg, work, &["diff", "--cached", "--name-only"]).await?.is_empty() { let mut args = IDENT.to_vec(); args.extend(["commit", "-m", msg]); git(cfg, work, &args).await?; } Ok(()) } /// Tag the commit and push default branch and tag. Returns a warning when the branch could not be /// pushed (e.g. protected): then the tag goes onto the commit already on the branch. async fn publish_version(cfg: &RepoCfg, work: &Path, base: &str, ver: &str, msg: &str) -> Result { let mut warn = String::new(); let target = format!("HEAD:refs/heads/{base}"); let mut pushed = git(cfg, work, &["push", "origin", &target]).await; if pushed.is_err() { // The branch moved meanwhile: put the version commit on top and try once more. let _ = git(cfg, work, &["fetch", "origin"]).await; let upstream = format!("origin/{base}"); let mut args = IDENT.to_vec(); args.extend(["rebase", &upstream]); if git(cfg, work, &args).await.is_ok() { pushed = git(cfg, work, &["push", "origin", &target]).await; } else { let _ = git(cfg, work, &["rebase", "--abort"]).await; } } if let Err(e) = pushed { warn = format!("the VERSION commit could not be pushed to {base} ({e:#}); the tag points to the branch head instead"); git(cfg, work, &["reset", "--hard", &format!("origin/{base}")]).await?; } let tag = format!("v{ver}"); let mut args = IDENT.to_vec(); args.extend(["tag", "-a", "-f", &tag, "-m", msg]); git(cfg, work, &args).await?; git(cfg, work, &["push", "origin", &format!("refs/tags/{tag}")]).await?; Ok(warn) } // --- version of merged issues ----------------------------------------------------------------- static BUSY: OnceLock>> = OnceLock::new(); /// Keeps two passes (poller and manual poll) from versioning the same repository at once. struct Busy(String); fn busy(repo: &str) -> Option { let set = BUSY.get_or_init(Default::default); set.lock().unwrap().insert(repo.to_string()).then(|| Busy(repo.to_string())) } impl Drop for Busy { fn drop(&mut self) { if let Some(set) = BUSY.get() { set.lock().unwrap().remove(&self.0); } } } fn pr_number(url: &str) -> u64 { url.trim_end_matches('/').rsplit('/').next().and_then(|n| n.parse().ok()).unwrap_or(0) } /// Give every merged, accepted issue its version. The first pass over a repository only /// sets the baseline: issues that were done before are not versioned. pub async fn version_pass(app: &Arc, user: &User, cfg: &RepoCfg) -> Result<()> { let Some(_guard) = busy(&cfg.url) else { return Ok(()) }; let rows: Vec = app.store.factory_issues(&user.id)?.into_iter().filter(|r| r["repo"].as_str() == Some(cfg.url.as_str())).collect(); let pending = |r: &&Value| matches!(r["state"].as_str(), Some("done") | Some("closed")) && r["version"].as_str() == Some("") && !r["pr_url"].as_str().unwrap_or("").is_empty(); if app.store.factory_version(&cfg.url)?.is_none() { let dir = checkout(app, user, cfg).await?; let cur = tags_version(cfg, &dir).await; for r in rows.iter().filter(|r| matches!(r["state"].as_str(), Some("done") | Some("closed")) && r["version"].as_str() == Some("")) { app.store.factory_issue_set(&cfg.url, issue_no(r), &[("version", json!("-"))])?; } app.store.factory_version_set(&cfg.url, &fmt(cur))?; return Ok(()); } let mut todo: Vec<&Value> = rows.iter().filter(pending).collect(); if todo.is_empty() { return Ok(()); } todo.sort_by_key(|r| issue_no(r)); let g = Forge::new(cfg)?; for r in todo { let n = issue_no(r); let pr_n = pr_number(r["pr_url"].as_str().unwrap_or("")); if pr_n == 0 { continue; } let pr = match g.pr(pr_n).await { Ok(p) => p, Err(e) => { tracing::warn!("factory {}#{n}: pull request: {e:#}", cfg.url); continue; } }; if pr["state"].as_str() != Some("merged") { continue; } // Remember it at once: if the version step below fails, the issue can still be closed by hand. let _ = app.store.factory_issue_set(&cfg.url, n, &[("merged", json!(1))]); let title = r["title"].as_str().unwrap_or("").to_string(); let others: Vec = g.open_issue_titles().await?.into_iter().filter(|(num, _)| *num != n).map(|(_, t)| t).collect(); let dir = checkout(app, user, cfg).await?; let cur = tags_version(cfg, &dir).await; let bump = bump_for(&title, &others); let new = fmt(next_version(cur, bump)); let base = base_branch(cfg, &dir).await; let (_, _, name) = cfg.parts()?; let work = fresh_worktree(cfg, &dir, "_release", &format!("{name}-version"), &base).await?; let msg = format!("Release v{new}: {title} (#{n})"); let published = async { commit_version(cfg, &work, &new, &msg).await?; publish_version(cfg, &work, &base, &new, &msg).await } .await; drop_worktree(cfg, &dir, &work).await; let warn = match published { Ok(w) => w, Err(e) => { tracing::warn!("factory {}#{n}: version {new}: {e:#}", cfg.url); continue; } }; let _ = checkout(app, user, cfg).await; // pulls the merge and the VERSION commit app.store.factory_issue_set(&cfg.url, n, &[("version", json!(new.clone())), ("state", json!("closed"))])?; app.store.factory_version_set(&cfg.url, &new)?; let _ = g.close_issue(n as u64).await; let why = if bump == Bump::Minor && milestone_of(&title).is_some() { " – the milestone is complete" } else { "" }; let extra = if warn.is_empty() { String::new() } else { format!("\n\nNote: {warn}.") }; bot_comment(&g, n as u64, &format!("**Version v{new}**{why}. The change is merged; tag `v{new}` and `VERSION` are on the default branch.{extra}")).await; notify(app, user, &format!("Factory #{n}"), &format!("v{new}{why}"), n).await; } Ok(()) } // --- manual release ---------------------------------------------------------------------------- /// `.factory/release.json`: how to build the downloads of a release. #[derive(Debug, Default, Deserialize)] pub struct ReleaseSpec { /// Docker image name without tag, e.g. registry.example.org/team/app (empty = no image). #[serde(default)] pub image: String, #[serde(default = "default_platforms")] pub platforms: String, #[serde(default = "default_dockerfile")] pub dockerfile: String, #[serde(default = "default_context")] pub context: String, #[serde(default)] pub build_args: HashMap, /// Shell commands run in the release checkout before the image is built (e.g. to make zips). #[serde(default)] pub commands: Vec, /// Files (globs relative to the checkout) attached to the release; the source zip is always attached. #[serde(default)] pub files: Vec, /// Name used for the source zip (default: the repository name). #[serde(default)] pub name: String, } fn default_platforms() -> String { "linux/amd64,linux/arm64".into() } fn default_dockerfile() -> String { "Dockerfile".into() } fn default_context() -> String { ".".into() } /// Run a command with a timeout; returns the last lines of its output. async fn run(cmd: &mut tokio::process::Command, timeout: Duration, stdin: Option<&str>) -> Result { use tokio::io::AsyncWriteExt; cmd.stdout(std::process::Stdio::piped()).stderr(std::process::Stdio::piped()).stdin(if stdin.is_some() { std::process::Stdio::piped() } else { std::process::Stdio::null() }).kill_on_drop(true); let mut child = cmd.spawn().context("could not start the command")?; if let (Some(text), Some(mut si)) = (stdin, child.stdin.take()) { si.write_all(text.as_bytes()).await?; } let out = tokio::time::timeout(timeout, child.wait_with_output()).await.map_err(|_| anyhow::anyhow!("timed out after {} min", timeout.as_secs() / 60))??; let text = format!("{}{}", String::from_utf8_lossy(&out.stdout), String::from_utf8_lossy(&out.stderr)); let tail: Vec<&str> = text.lines().rev().take(25).collect::>().into_iter().rev().collect(); let tail = tail.join("\n"); if !out.status.success() { bail!("{}", tail); } Ok(tail) } fn clean_env(cmd: &mut tokio::process::Command, extra: &[(&str, &str)]) { cmd.env_clear().env("PATH", std::env::var("PATH").unwrap_or_default()).env("HOME", "/tmp"); for (k, v) in extra { cmd.env(k, v); } } /// Current version, suggested next major version and the release recipe of the default branch. pub async fn preview(app: &Arc, user: &User, cfg: &RepoCfg) -> Result { let dir = checkout(app, user, cfg).await?; let cur = tags_version(cfg, &dir).await; let base = base_branch(cfg, &dir).await; let spec = git(cfg, &dir, &["show", &format!("origin/{base}:.factory/release.json")]).await.ok(); Ok(json!({"current": fmt(cur), "suggested": fmt((cur.0 + 1, 0, 0)), "spec": spec, "running": app.store.factory_release_running(&cfg.url)?})) } /// Validate and start a release in the background; returns the release id. pub async fn start_release(app: &Arc, user: &User, cfg: &RepoCfg, version: &str) -> Result { let Some(new) = parse_version(version) else { bail!("the version must look like 1.0.0") }; if app.store.factory_release_running(&cfg.url)? { bail!("a release of this repository is already running"); } let dir = checkout(app, user, cfg).await?; let cur = tags_version(cfg, &dir).await; if new <= cur { bail!("v{} is not newer than the current version v{}", fmt(new), fmt(cur)); } let id = crate::types::new_id(); app.store.factory_release_add(&id, &user.id, &cfg.url, &fmt(new))?; let (app, user, cfg, rid) = (app.clone(), user.clone(), cfg.clone(), id.clone()); tokio::spawn(async move { let log = |m: &str| { let _ = app.store.factory_release_log(&rid, m); }; match run_release(&app, &user, &cfg, new, &rid, &log).await { Ok(url) => { let _ = app.store.factory_release_end(&rid, "done", &url); notify(&app, &user, "Factory release", &format!("v{} released", fmt(new)), 0).await; } Err(e) => { log(&format!("FAILED: {e:#}")); let _ = app.store.factory_release_end(&rid, "failed", ""); notify(&app, &user, "Factory release", &format!("v{} failed", fmt(new)), 0).await; } } }); Ok(id) } async fn run_release(app: &Arc, user: &User, cfg: &RepoCfg, new: Ver, rid: &str, log: &(dyn Fn(&str) + Sync)) -> Result { let ver = fmt(new); let tag = format!("v{ver}"); let dir = checkout(app, user, cfg).await?; let base = base_branch(cfg, &dir).await; let (_, _, name) = cfg.parts()?; let g = Forge::new(cfg)?; log(&format!("release {tag} from {base}")); let work = fresh_worktree(cfg, &dir, "_release", &format!("{name}-release"), &base).await?; let tmp = std::env::temp_dir().join(format!("factory-release-{rid}")); std::fs::create_dir_all(&tmp)?; let result = release_steps(cfg, &g, &work, &tmp, &base, &name, &ver, &tag, rid, log).await; drop_worktree(cfg, &dir, &work).await; let _ = std::fs::remove_dir_all(&tmp); result } #[allow(clippy::too_many_arguments)] async fn release_steps(cfg: &RepoCfg, g: &Forge, work: &Path, tmp: &Path, base: &str, name: &str, ver: &str, tag: &str, rid: &str, log: &(dyn Fn(&str) + Sync)) -> Result { let msg = format!("Release {tag}"); commit_version(cfg, work, ver, &msg).await?; let spec: ReleaseSpec = match std::fs::read_to_string(work.join(".factory/release.json")) { Ok(t) => serde_json::from_str(&t).context(".factory/release.json is not valid")?, Err(_) => { log("no .factory/release.json – only the tag, the release and the source zip are made"); ReleaseSpec::default() } }; let hour = Duration::from_secs(3600); for cmd in &spec.commands { log(&format!("$ {cmd}")); let mut c = tokio::process::Command::new("bash"); c.arg("-c").arg(cmd).current_dir(work); clean_env(&mut c, &[("VERSION", ver), ("CI", "1")]); log(&run(&mut c, hour, None).await?); } if !spec.image.trim().is_empty() { build_image(cfg, g, &spec, work, tmp, ver, rid, log).await?; } // Publish: branch + tag, then the release with its files. let warn = publish_version(cfg, work, base, ver, &msg).await?; if !warn.is_empty() { log(&format!("note: {warn}")); } log(&format!("tag {tag} pushed")); let prev = git(cfg, work, &["tag", "-l", "v[0-9]*"]).await.unwrap_or_default().lines().filter_map(|t| parse_version(t).map(|v| (v, t.to_string()))).filter(|(v, _)| fmt(*v) != ver && *v < parse_version(ver).unwrap_or((0, 0, 0))).max().map(|(_, t)| t); let range = prev.as_ref().map(|p| format!("{p}..{tag}")).unwrap_or_else(|| tag.to_string()); let changes = git(cfg, work, &["log", "--pretty=format:- %s", "--max-count=200", &range]).await.unwrap_or_default(); let mut notes = format!("Release {tag}\n\n"); if !spec.image.trim().is_empty() { notes.push_str(&format!("Docker image: `{}:{ver}` ({})\n\n", spec.image.trim(), spec.platforms)); } notes.push_str(&format!("## Changes\n\n{changes}\n")); let rel = g.create_release(tag, &format!("{name} {tag}"), ¬es).await?; let url = rel["html_url"].as_str().unwrap_or("").to_string(); log(&format!("release created {url}")); // Downloads: the source zip and the configured files. let zip_name = format!("{}-{ver}-source.zip", Some(spec.name.trim()).filter(|n| !n.is_empty()).unwrap_or(name)); let zip = tmp.join(&zip_name); git(cfg, work, &["archive", "--format=zip", &format!("--prefix={name}-{ver}/"), "-o", &zip.display().to_string(), "HEAD"]).await?; let mut files: Vec<(String, PathBuf)> = vec![(zip_name, zip)]; if !spec.files.is_empty() { let mut builder = globset::GlobSetBuilder::new(); for f in &spec.files { builder.add(globset::Glob::new(f).with_context(|| format!("bad file pattern {f}"))?); } let set = builder.build()?; let mut stack = vec![work.to_path_buf()]; while let Some(d) = stack.pop() { for e in std::fs::read_dir(&d)?.flatten() { let p = e.path(); let rel_path = p.strip_prefix(work).unwrap_or(&p).to_path_buf(); if rel_path.starts_with(".git") || rel_path.starts_with("node_modules") || rel_path.starts_with("target") && !set.is_match(&rel_path) { continue; } if p.is_dir() { stack.push(p); } else if set.is_match(&rel_path) && files.len() < 60 { files.push((e.file_name().to_string_lossy().to_string(), p)); } } } } for (fname, path) in &files { match g.upload_asset(&rel["id"], fname, path).await { Ok(()) => log(&format!("attached {fname}")), Err(e) => log(&format!("not attached: {e:#}")), } } Ok(url) } /// Build and push the multi-arch Docker image with buildx (own builder, own login, both removed afterwards). #[allow(clippy::too_many_arguments)] async fn build_image(cfg: &RepoCfg, g: &Forge, spec: &ReleaseSpec, work: &Path, tmp: &Path, ver: &str, rid: &str, log: &(dyn Fn(&str) + Sync)) -> Result<()> { let image = spec.image.trim(); let first = image.split('/').next().unwrap_or(""); let host = if image.contains('/') && (first.contains('.') || first.contains(':')) { first } else { "docker.io" }; let conf = tmp.join("docker"); std::fs::create_dir_all(&conf)?; let conf_s = conf.display().to_string(); let builder = format!("factory-{}", &rid[..8.min(rid.len())]); let minute = Duration::from_secs(120); let env = [("DOCKER_CONFIG", conf_s.as_str())]; let mut c = tokio::process::Command::new("docker"); c.args(["buildx", "version"]); clean_env(&mut c, &env); run(&mut c, minute, None).await.context("docker buildx is not available in this installation")?; let login = g.login().await?; log(&format!("docker login {host}")); let mut c = tokio::process::Command::new("docker"); c.args(["login", host, "-u", &login, "--password-stdin"]); clean_env(&mut c, &env); run(&mut c, minute, Some(&cfg.token)).await.context("docker login failed")?; let mut c = tokio::process::Command::new("docker"); c.args(["buildx", "create", "--name", &builder, "--driver", "docker-container"]); clean_env(&mut c, &env); run(&mut c, minute, None).await.context("could not create the buildx builder")?; let mut args: Vec = ["buildx", "build", "--builder", &builder, "--platform", &spec.platforms, "-f", &spec.dockerfile, "-t", &format!("{image}:{ver}"), "-t", &format!("{image}:latest"), "--build-arg", &format!("VERSION={ver}")].iter().map(|s| s.to_string()).collect(); for (k, v) in &spec.build_args { args.extend(["--build-arg".to_string(), format!("{k}={v}")]); } args.extend(["--push".to_string(), spec.context.clone()]); log(&format!("docker buildx build {} → {image}:{ver}", spec.platforms)); let mut c = tokio::process::Command::new("docker"); c.args(&args).current_dir(work); clean_env(&mut c, &env); let built = run(&mut c, Duration::from_secs(3 * 3600), None).await; let mut c = tokio::process::Command::new("docker"); c.args(["buildx", "rm", "--force", &builder]); clean_env(&mut c, &env); let _ = run(&mut c, minute, None).await; log(&built.context("the image build failed")?); log("image pushed"); Ok(()) } #[cfg(test)] mod tests { use super::*; #[test] fn parses_and_formats_versions() { assert_eq!(parse_version("v1.2.3"), Some((1, 2, 3))); assert_eq!(parse_version("0.0.0"), Some((0, 0, 0))); assert_eq!(parse_version("1.2"), None); assert_eq!(parse_version("1.2.3.4"), None); assert_eq!(parse_version("vx.1.2"), None); assert_eq!(fmt((0, 1, 10)), "0.1.10"); assert!(parse_version("0.10.0") > parse_version("0.9.9")); } #[test] fn reads_milestones_from_titles() { assert_eq!(milestone_of("M1.3 – Import"), Some((1, Some(3)))); assert_eq!(milestone_of("M12.10 - x"), Some((12, Some(10)))); assert_eq!(milestone_of("M1 – Foundation"), Some((1, None))); assert_eq!(milestone_of("M0"), Some((0, None))); assert_eq!(milestone_of("Make it faster"), None); assert_eq!(milestone_of("M1abc"), None); assert_eq!(milestone_of("Fix login"), None); } #[test] fn issues_raise_patch_and_the_last_one_of_a_milestone_the_minor() { let open = |v: &[&str]| v.iter().map(|s| s.to_string()).collect::>(); // other M1 issues still open: patch assert_eq!(bump_for("M1.3 – Import", &open(&["M1.4 – Debayering", "M2.1 – Mail"])), Bump::Patch); // the last open M1 issue: minor (other milestones do not matter) assert_eq!(bump_for("M1.11 – Log", &open(&["M2.1 – Mail", "Fix typo"])), Bump::Minor); assert_eq!(bump_for("Fix login bug", &open(&["M1.1 – x"])), Bump::Patch); assert_eq!(bump_for("M3 – Mosaics", &open(&[])), Bump::Minor); assert_eq!(next_version((0, 0, 7), Bump::Patch), (0, 0, 8)); assert_eq!(next_version((0, 0, 10), Bump::Minor), (0, 1, 0)); assert_eq!(next_version((0, 1, 4), Bump::Minor), (0, 2, 0)); } #[test] fn release_spec_has_defaults() { let s: ReleaseSpec = serde_json::from_str(r#"{"image": "r.example/app"}"#).unwrap(); assert_eq!((s.platforms.as_str(), s.dockerfile.as_str(), s.context.as_str()), ("linux/amd64,linux/arm64", "Dockerfile", ".")); assert!(s.commands.is_empty() && s.files.is_empty()); } #[tokio::test] async fn sync_default_pulls_what_was_merged() { let run = |dir: &Path, args: &[&str]| { let o = std::process::Command::new("git").args(["-c", "user.name=t", "-c", "user.email=t@t", "-c", "init.defaultBranch=main"]).args(args).current_dir(dir).output().unwrap(); assert!(o.status.success(), "git {args:?}: {}", String::from_utf8_lossy(&o.stderr)); }; let root = std::env::temp_dir().join(format!("factory-sync-{}", std::process::id())); let _ = std::fs::remove_dir_all(&root); std::fs::create_dir_all(&root).unwrap(); run(&root, &["init", "-q", "--bare", "origin.git"]); run(&root, &["clone", "-q", "origin.git", "a"]); std::fs::write(root.join("a/one.txt"), "1").unwrap(); run(&root.join("a"), &["add", "."]); run(&root.join("a"), &["commit", "-qm", "one"]); run(&root.join("a"), &["push", "-q", "origin", "HEAD:main"]); run(&root, &["--git-dir=origin.git", "symbolic-ref", "HEAD", "refs/heads/main"]); run(&root, &["clone", "-q", "origin.git", "checkout"]); // somebody merges a second change on the remote std::fs::write(root.join("a/two.txt"), "2").unwrap(); run(&root.join("a"), &["add", "."]); run(&root.join("a"), &["commit", "-qm", "two"]); run(&root.join("a"), &["push", "-q", "origin", "HEAD:main"]); let cfg: RepoCfg = serde_json::from_value(json!({"url": "https://g.example/o/r.git", "token": "t"})).unwrap(); let dir = root.join("checkout"); git(&cfg, &dir, &["fetch", "origin"]).await.unwrap(); assert!(!dir.join("two.txt").exists(), "a fetch alone does not update the files"); sync_default(&cfg, &dir).await.unwrap(); assert!(dir.join("two.txt").exists()); // local changes block switching, nothing is damaged std::fs::write(dir.join("one.txt"), "edited").unwrap(); sync_default(&cfg, &dir).await.unwrap(); assert_eq!(std::fs::read_to_string(dir.join("one.txt")).unwrap(), "edited"); let _ = std::fs::remove_dir_all(&root); } #[test] fn pr_numbers_come_from_urls() { assert_eq!(pr_number("https://g.example/o/r/pulls/72"), 72); assert_eq!(pr_number("https://g.example/o/r/-/merge_requests/5/"), 5); assert_eq!(pr_number(""), 0); } #[test] fn busy_guard_blocks_a_second_pass() { let a = busy("https://g.example/o/busy-test"); assert!(a.is_some()); assert!(busy("https://g.example/o/busy-test").is_none()); drop(a); assert!(busy("https://g.example/o/busy-test").is_some()); } }