#![allow(clippy::disallowed_methods)]
mod support;
use std::fs;
use std::path::{Path, PathBuf};
#[cfg(unix)]
use std::process::Command;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::Arc;
use httpmock::prelude::*;
use serde_json::json;
use support::fixture::{
cargo_package, commit, git, git_repo, git_stdout, oakum, pinned_config, private_workspace,
sibling, tag_members_at_version, Fixture,
};
#[cfg(unix)]
use support::fixture::{install_executable, path_prefixed_by};
fn temp_git_repo(label: &str) -> Fixture {
let root = git_repo("release", label);
pinned_config(&root);
root
}
fn oakum_release(root: &Path) -> std::process::Command {
let mut cmd = oakum(root);
cmd.env_remove("GITHUB_GRAPHQL_URL");
cmd.env_remove("GITHUB_ACTIONS");
cmd.env("OAKUM_HANDOFF_FAST", "1");
cmd
}
fn run_release_exit(root: &Path) -> (Option<i32>, String, String) {
let out = oakum_release(root)
.arg("release")
.env_remove("GITHUB_TOKEN")
.env_remove("GH_TOKEN")
.output()
.expect("oakum release");
(
out.status.code(),
String::from_utf8_lossy(&out.stdout).into_owned(),
String::from_utf8_lossy(&out.stderr).into_owned(),
)
}
fn run_release(root: &Path) -> (bool, String, String) {
let out = oakum_release(root)
.arg("release")
.env_remove("GITHUB_TOKEN")
.env_remove("GH_TOKEN")
.output()
.expect("oakum release");
(
out.status.success(),
String::from_utf8_lossy(&out.stdout).into_owned(),
String::from_utf8_lossy(&out.stderr).into_owned(),
)
}
fn local_tags(root: &Path) -> String {
git_stdout(root, &["tag", "--list"])
}
fn commit_at(root: &Path, reference: &str) -> String {
git_stdout(root, &["rev-parse", &format!("{reference}^{{commit}}")])
}
fn assert_annotated(root: &Path, name: &str) {
assert_eq!(git_stdout(root, &["cat-file", "-t", name]), "tag", "{name}");
}
fn pending_demo(label: &str) -> Fixture {
let root = temp_git_repo(label);
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
cargo_package(&root, "demo", "0.1.1");
commit(&root, "version");
root
}
fn add_bare_origin(root: &Fixture) -> PathBuf {
let remote = sibling(root, "origin.git");
assert_eq!(
remote.file_name().and_then(|n| n.to_str()),
Some("origin.git")
);
git(root, &["init", "--bare", remote.to_str().expect("utf-8")]);
git(
root,
&["remote", "add", "origin", remote.to_str().expect("utf-8")],
);
remote
}
fn write_workflow(root: &Path, name: &str, body: &str) {
let dir = root.join(".github/workflows");
fs::create_dir_all(&dir).expect("workflows");
fs::write(dir.join(name), body).expect("workflow");
}
fn head_sha(root: &Path) -> String {
git_stdout(root, &["rev-parse", "HEAD"])
}
#[derive(Clone)]
enum RunHit {
Empty,
Run {
id: u64,
path: String,
branch: &'static str,
},
Runs {
ids: Vec<u64>,
path: String,
branch: &'static str,
},
RunWithoutPath {
id: u64,
},
RunWithoutEvent {
id: u64,
path: String,
},
Event {
id: u64,
path: String,
event: &'static str,
branch: Option<&'static str>,
},
Page(Vec<(u64, String, &'static str, Option<&'static str>)>),
Incomplete(Vec<PartialRun>),
Fail(u16),
}
type PartialRun = (
u64,
Option<String>,
Option<&'static str>,
Option<&'static str>,
);
fn run_json(
sha: &str,
id: u64,
path: Option<&str>,
event: Option<&str>,
branch: Option<&str>,
) -> serde_json::Value {
let mut run = json!({
"id": id,
"head_sha": sha,
"status": "queued",
"conclusion": null,
"html_url": format!("https://github.com/oakoss/oakum/actions/runs/{id}")
});
if let Some(path) = path {
run["path"] = json!(path);
}
if let Some(event) = event {
run["event"] = json!(event);
}
if let Some(branch) = branch {
run["head_branch"] = json!(branch);
}
run
}
fn run_hit_response(sha: &str, hit: &RunHit) -> (u16, serde_json::Value) {
match hit {
RunHit::Empty => (200, json!({ "total_count": 0, "workflow_runs": [] })),
RunHit::Run { id, path, branch } => (
200,
json!({
"total_count": 1,
"workflow_runs": [run_json(sha, *id, Some(path), Some("push"), Some(branch))]
}),
),
RunHit::Runs { ids, path, branch } => (
200,
json!({
"total_count": ids.len(),
"workflow_runs": ids.iter().map(|id| run_json(sha, *id, Some(path), Some("push"), Some(branch))).collect::<Vec<_>>()
}),
),
RunHit::RunWithoutPath { id } => (
200,
json!({
"total_count": 1,
"workflow_runs": [run_json(sha, *id, None, Some("push"), None)]
}),
),
RunHit::RunWithoutEvent { id, path } => (
200,
json!({
"total_count": 1,
"workflow_runs": [run_json(sha, *id, Some(path), None, None)]
}),
),
RunHit::Event {
id,
path,
event,
branch,
} => (
200,
json!({
"total_count": 1,
"workflow_runs": [run_json(sha, *id, Some(path), Some(event), *branch)]
}),
),
RunHit::Page(runs) => (
200,
json!({
"total_count": runs.len(),
"workflow_runs": runs
.iter()
.map(|(id, path, event, branch)| run_json(sha, *id, Some(path), Some(event), *branch))
.collect::<Vec<_>>()
}),
),
RunHit::Incomplete(runs) => (
200,
json!({
"total_count": runs.len(),
"workflow_runs": runs
.iter()
.map(|(id, path, event, branch)| run_json(sha, *id, path.as_deref(), *event, *branch))
.collect::<Vec<_>>()
}),
),
RunHit::Fail(status) => (*status, json!({ "message": "error" })),
}
}
fn mock_workflow_runs<'a>(
server: &'a MockServer,
sha: &str,
path: &str,
empty: bool,
) -> httpmock::Mock<'a> {
let (status, runs) = if empty {
run_hit_response(sha, &RunHit::Empty)
} else {
run_hit_response(
sha,
&RunHit::Run {
id: 9,
path: path.to_owned(),
branch: "v0.1.1",
},
)
};
server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/actions/runs")
.query_param("head_sha", sha)
.query_param("per_page", "100");
then.status(status).json_body(runs);
})
}
fn mock_workflow_hits<'a>(
server: &'a MockServer,
sha: &str,
hits: &[RunHit],
) -> Vec<httpmock::Mock<'a>> {
let n = Arc::new(AtomicUsize::new(0));
hits.iter()
.enumerate()
.map(|(i, hit)| {
let n = n.clone();
let (status, body) = run_hit_response(sha, hit);
server.mock(move |when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/actions/runs")
.query_param("head_sha", sha)
.query_param("per_page", "100")
.is_true(move |_| {
if n.load(Ordering::SeqCst) == i {
n.fetch_add(1, Ordering::SeqCst);
true
} else {
false
}
});
then.status(status).json_body(body);
})
})
.collect()
}
#[test]
fn no_token_cannot_confirm_a_tag_was_released() {
let root = temp_git_repo("clean");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
add_bare_origin(&root);
let (code, stdout, stderr) = run_release_exit(&root);
assert!(stderr.contains("unverified"), "{stderr}");
assert_eq!(
code,
Some(2),
"unverified is exit 2, not merely non-zero: {stdout}{stderr}"
);
assert!(
stderr.contains("GITHUB_TOKEN and GH_TOKEN are both unset"),
"the refusal must name what was missing: {stderr}"
);
assert!(
!stdout.contains("nothing to release"),
"a look that never happened must not print a verdict: {stdout}"
);
}
#[test]
fn no_tag_at_head_answers_locally_without_a_token() {
let root = temp_git_repo("locally-answerable");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
let (ok, stdout, stderr) = run_release(&root);
assert!(ok, "a local answer must not refuse: {stdout}{stderr}");
assert!(stdout.contains("nothing to release"), "{stdout}");
}
#[test]
fn a_tag_behind_head_cannot_be_confirmed_without_a_token() {
let root = temp_git_repo("tag-behind-head");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
fs::write(root.join("after.txt"), "later").expect("after");
commit(&root, "later");
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "a look that never happened must not pass: {stdout}");
assert!(
stderr.contains("unverified: a tagged version has no local plan"),
"{stderr}"
);
assert!(
!stdout.contains("nothing to release"),
"a look that never happened must not print a verdict: {stdout}"
);
}
#[test]
fn neither_remote_nor_token_names_both() {
let root = temp_git_repo("neither-prerequisite");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
let (ok, _stdout, stderr) = run_release(&root);
assert!(!ok, "{stderr}");
assert!(stderr.contains("this repository has no remote"), "{stderr}");
assert!(
stderr.contains("GITHUB_TOKEN and GH_TOKEN are both unset"),
"the message must name both, not one: {stderr}"
);
}
#[test]
fn no_remote_cannot_confirm_a_tag_was_released() {
let root = temp_git_repo("unreleased-no-remote");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "test-token")
.output()
.expect("oakum release");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(!out.status.success(), "{stderr}");
assert!(stderr.contains("unverified"), "{stderr}");
assert!(
stderr.contains("this repository has no remote"),
"the refusal must name what was missing: {stderr}"
);
assert!(
stderr.contains("missing its release"),
"this must be the could-not-look refusal, not the push-target one: {stderr}"
);
}
#[test]
fn leftover_tag_is_unverified_and_creates_no_tag() {
let root = temp_git_repo("leftover");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "other-v1.0.0"]);
let check = oakum_release(&root).arg("check").output().expect("check");
let release = oakum_release(&root)
.arg("release")
.env_remove("GITHUB_TOKEN")
.env_remove("GH_TOKEN")
.output()
.expect("release");
assert!(!check.status.success());
assert!(!release.status.success());
let check_err = String::from_utf8_lossy(&check.stderr);
let release_err = String::from_utf8_lossy(&release.stderr);
assert!(check_err.contains("unverified"), "{check_err}");
assert!(release_err.contains("unverified"), "{release_err}");
assert!(release_err.contains("other-v1.0.0"), "{release_err}");
assert_eq!(local_tags(&root).trim(), "other-v1.0.0");
}
#[test]
fn tag_drift_fails_check_and_release_needs_a_token() {
let root = pending_demo("drift-token");
add_bare_origin(&root);
let check = oakum_release(&root).arg("check").output().expect("check");
assert!(!check.status.success());
let check_err = String::from_utf8_lossy(&check.stderr);
assert!(check_err.contains("above tagged"), "{check_err}");
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(
stderr.contains("GITHUB_TOKEN") && stderr.contains("GH_TOKEN"),
"{stderr}"
);
assert!(!stderr.contains("bumped without a tag"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn skip_ci_head_creates_no_tag() {
let root = temp_git_repo("skip");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
cargo_package(&root, "demo", "0.1.1");
commit(&root, "version [skip ci]");
add_bare_origin(&root);
let server = MockServer::start();
let lookup = mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stderr_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("skip-ci"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
lookup.assert_calls(1);
create.assert_calls(0);
}
#[test]
fn skip_ci_head_stops_a_resume_before_it_releases() {
let root = temp_git_repo("skip-resume");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "version [skip ci]");
git(&root, &["tag", "v0.1.0"]);
add_bare_origin(&root);
let server = MockServer::start();
let lookup = mock_lookup_empty(&server, "v0.1.0");
let create = mock_create(&server, "v0.1.0", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stderr_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("skip-ci"), "{stderr}");
lookup.assert_calls(1);
create.assert_calls(0);
}
#[test]
fn skip_ci_tagged_commit_stops_a_resume_even_after_head_moves() {
let root = temp_git_repo("skip-resume-behind");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "version [skip ci]");
git(&root, &["tag", "v0.1.0"]);
fs::write(root.join("README.md"), "docs\n").expect("readme");
commit(&root, "docs: clean follow-up");
add_bare_origin(&root);
let server = MockServer::start();
let lookup = mock_lookup_empty(&server, "v0.1.0");
let create = mock_create(&server, "v0.1.0", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stderr_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("skip-ci"), "{stderr}");
assert!(stderr.contains("v0.1.0"), "{stderr}");
lookup.assert_calls(1);
create.assert_calls(0);
}
#[test]
fn skip_ci_tagged_commit_with_existing_release_is_nothing_to_release() {
let root = temp_git_repo("skip-released");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "chore(release): v0.1.0 [skip ci]");
git(&root, &["tag", "v0.1.0"]);
add_bare_origin(&root);
git(&root, &["push", "origin", "refs/tags/v0.1.0"]);
let server = MockServer::start();
let lookup = server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.0");
then.status(200).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.0",
"tag_name": "v0.1.0"
}));
});
let create = mock_create(&server, "v0.1.0", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
assert!(
stdout_of(&out).contains("nothing to release"),
"{}",
stdout_of(&out)
);
lookup.assert_calls(1);
create.assert_calls(0);
}
#[test]
fn skip_ci_head_with_nothing_to_release_answers_locally() {
let root = temp_git_repo("skip-noop");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "docs: fix [skip ci]");
add_bare_origin(&root);
let (ok, stdout, stderr) = run_release(&root);
assert!(ok, "{stdout}{stderr}");
assert!(stdout.contains("nothing to release"), "{stdout}");
}
#[test]
fn a_non_github_remote_reports_unverified() {
let root = temp_git_repo("gitlab-remote");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
git(
&root,
&[
"remote",
"add",
"origin",
"https://gitlab.invalid/oakoss/demo.git",
],
);
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env_remove("GITHUB_REPOSITORY")
.output()
.expect("release");
assert!(!out.status.success(), "a slugless remote must not pass");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(
stderr.contains("not a github.com owner/repo URL"),
"{stderr}"
);
}
#[test]
fn no_config_is_unverified_and_creates_no_tag() {
let root = git_repo("release", "no-config");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
cargo_package(&root, "demo", "0.1.1");
commit(&root, "version");
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(
stderr.contains(
"unverified: `.changeset/_config.toml` not found; run `oakum init` or `oakum migrate`"
),
"{stderr}"
);
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn tool_version_mismatch_creates_no_tag() {
let root = pending_demo("toolver");
fs::create_dir_all(root.join(".changeset")).expect("changeset");
fs::write(
root.join(".changeset/_config.toml"),
"tool-version = \"9.9.9\"\n",
)
.expect("config");
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(
stderr.contains("`tool-version` is `9.9.9` but this binary is"),
"{stderr}"
);
assert!(stderr.contains("run `oakum upgrade`"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn creates_github_release_when_remote_tag_already_at_head() {
let root = pending_demo("remote-at-head");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
git(&root, &["tag", "-d", "v0.1.1"]);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
assert!(
stdout_of(&out).contains("https://github.com/oakoss/oakum/releases/tag/v0.1.1"),
"{}",
stdout_of(&out)
);
create.assert();
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn remote_tag_at_other_commit_creates_no_github_release() {
let root = temp_git_repo("remote-other");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
git(&root, &["tag", "v0.1.1"]);
add_bare_origin(&root);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
git(&root, &["tag", "-d", "v0.1.1"]);
cargo_package(&root, "demo", "0.1.1");
commit(&root, "version");
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("already has tag"), "{stderr}");
create.assert_calls(0);
assert!(
!local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
}
#[cfg(unix)]
#[test]
fn a_second_push_url_over_ssh_still_gets_the_note() {
let root = pending_demo("pushurl-many");
add_bare_origin(&root);
let bare = sibling(&root, "pushurl-many.git");
git(
&root,
&[
"config",
"--add",
"remote.origin.pushurl",
bare.to_str().expect("utf-8"),
],
);
git(
&root,
&[
"config",
"--add",
"remote.origin.pushurl",
"git+ssh://git@example.invalid/demo.git",
],
);
let server = MockServer::start();
server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.1");
then.status(404).body("Not Found");
});
server.mock(|when, then| {
when.method(POST).path("/repos/oakoss/oakum/releases");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1"
}));
});
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.env_remove("GIT_SSH_COMMAND")
.env("GIT_SSH", "/usr/local/bin/my-ssh")
.output()
.expect("release");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(
stderr.contains("cannot refuse ssh prompts"),
"a later push URL over ssh must still be warned about: {stderr}"
);
}
#[cfg(unix)]
#[test]
fn an_identical_note_owed_by_both_directions_is_said_once() {
let root = pending_demo("note-per-direction");
add_bare_origin(&root);
let server = MockServer::start();
server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.1");
then.status(404).body("Not Found");
});
server.mock(|when, then| {
when.method(POST).path("/repos/oakoss/oakum/releases");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1"
}));
});
let scratch = sibling(&root, "note-direction");
let shim_dir = scratch.join("shim");
fs::create_dir_all(&shim_dir).expect("shim dir");
let real = String::from_utf8(
Command::new("sh")
.args(["-c", "command -v git"])
.output()
.expect("which git")
.stdout,
)
.expect("utf-8");
let shim = shim_dir.join("git");
install_executable(
&shim,
format!(
"#!/bin/sh\ncase \"$*\" in\n\
'remote -v') echo 'fatal: unable to read config file' >&2; exit 128 ;;\n\
esac\nexec {real} \"$@\"\n",
real = real.trim()
),
);
let out = oakum_release(&root)
.arg("release")
.env("PATH", path_prefixed_by(&shim_dir))
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.env_remove("GIT_SSH_COMMAND")
.env("GIT_SSH", "/usr/local/bin/my-ssh")
.output()
.expect("release");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(
out.status.success(),
"stdout={} stderr={stderr}",
String::from_utf8_lossy(&out.stdout)
);
let notes = stderr
.lines()
.filter(|line| line.contains("could not establish what transport"))
.count();
assert_eq!(
notes, 1,
"the identical note must be said exactly once, got {notes}: {stderr}"
);
}
#[cfg(unix)]
#[test]
fn a_push_url_that_uses_ssh_gets_the_note_when_the_fetch_url_does_not() {
let root = pending_demo("pushurl-ssh");
add_bare_origin(&root);
git(
&root,
&[
"config",
"remote.origin.pushurl",
"git+ssh://git@example.invalid/demo.git",
],
);
let server = MockServer::start();
server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.1");
then.status(404).body("Not Found");
});
server.mock(|when, then| {
when.method(POST).path("/repos/oakoss/oakum/releases");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1"
}));
});
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.env_remove("GIT_SSH_COMMAND")
.env("GIT_SSH", "/usr/local/bin/my-ssh")
.output()
.expect("release");
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(
stderr.contains("cannot refuse ssh prompts"),
"a push over ssh must be warned even when the fetch URL is not: {stderr}"
);
}
#[cfg(unix)]
#[test]
fn the_ssh_transport_is_read_once_however_many_remote_children_run() {
let root = pending_demo("probe-once");
add_bare_origin(&root);
let server = MockServer::start();
server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.1");
then.status(404).body("Not Found");
});
server.mock(|when, then| {
when.method(POST).path("/repos/oakoss/oakum/releases");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1"
}));
});
let scratch = sibling(&root, "probe-once-scratch");
let log = scratch.join("git-argv.log");
let shim_dir = scratch.join("shim");
fs::create_dir_all(&shim_dir).expect("shim dir");
let real = String::from_utf8(
Command::new("sh")
.args(["-c", "command -v git"])
.output()
.expect("which git")
.stdout,
)
.expect("utf-8");
let shim = shim_dir.join("git");
install_executable(
&shim,
format!(
"#!/bin/sh\nprintf '%s\\n' \"$*\" >> {log}\nexec {real} \"$@\"\n",
log = log.to_str().expect("utf-8 log"),
real = real.trim()
),
);
let out = oakum_release(&root)
.arg("release")
.env("PATH", path_prefixed_by(&shim_dir))
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.env_remove("GIT_SSH_COMMAND")
.env("GIT_SSH", "/usr/local/bin/my-ssh")
.output()
.expect("release");
assert!(
out.status.success(),
"stdout={} stderr={}",
String::from_utf8_lossy(&out.stdout),
String::from_utf8_lossy(&out.stderr)
);
let argv = fs::read_to_string(&log).unwrap_or_default();
let probes = argv
.lines()
.filter(|line| line.contains("sshcommand"))
.count();
let remote_children = argv
.lines()
.filter(|line| line.starts_with("ls-remote") || line.starts_with("push"))
.count();
assert!(
remote_children >= 2,
"the release should make more than one remote child, got {remote_children}:\n{argv}"
);
assert_eq!(
probes, 1,
"the transport should be read once, not once per remote child \
({remote_children} of those):\n{argv}"
);
let listings = argv.lines().filter(|line| *line == "remote -v").count();
let url_probes = argv
.lines()
.filter(|line| line.starts_with("remote get-url"))
.count();
assert_eq!(
(listings, url_probes),
(1, 0),
"one listing for the whole run, no per-remote URL children \
({remote_children} remote children):\n{argv}"
);
}
#[test]
fn tags_and_creates_a_github_release() {
let root = pending_demo("happy");
add_bare_origin(&root);
let server = MockServer::start();
server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.1");
then.status(404).body("Not Found");
});
let create = server.mock(|when, then| {
when.method(POST)
.path("/repos/oakoss/oakum/releases")
.body_includes("\"tag_name\":\"v0.1.1\"");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1"
}));
});
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.output()
.expect("release");
assert!(
out.status.success(),
"stdout={} stderr={}",
String::from_utf8_lossy(&out.stdout),
String::from_utf8_lossy(&out.stderr)
);
let stdout = String::from_utf8_lossy(&out.stdout);
assert!(
stdout.contains("https://github.com/oakoss/oakum/releases/tag/v0.1.1"),
"{stdout}"
);
create.assert();
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
assert_annotated(&root, "v0.1.1");
let listed = git_stdout(&root, &["ls-remote", "--tags", "origin"]);
assert!(listed.contains("refs/tags/v0.1.1"), "{listed}");
}
#[cfg(unix)]
#[test]
fn honor_git_calls_repo_gpg_program() {
let root = pending_demo("honor-git");
add_bare_origin(&root);
let tools = sibling(&root, "sign");
fs::create_dir_all(&tools).expect("sign tools");
let log = tools.join("fake-gpg.log");
let stub = tools.join("fake-gpg");
let editor_ran = tools.join("editor-ran");
let editor = tools.join("fake-editor");
install_executable(
&stub,
format!(
"#!/bin/sh\nprintf '%s\\n' \"$0 $*\" >> '{}'\nexit 1\n",
log.display()
),
);
install_executable(
&editor,
format!(
"#!/bin/sh\necho ran >> '{}'\nexit 1\n",
editor_ran.display()
),
);
git(
&root,
&["config", "gpg.program", stub.to_str().expect("utf-8 stub")],
);
git(&root, &["config", "tag.gpgsign", "true"]);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.env("GIT_EDITOR", editor.to_str().expect("utf-8 editor"))
.output()
.expect("release");
let recorded = fs::read_to_string(&log).unwrap_or_default();
assert!(
recorded.contains("fake-gpg"),
"gpg log: {recorded:?} stdout={} stderr={}",
stdout_of(&out),
stderr_of(&out)
);
assert!(
!out.status.success(),
"stdout={} stderr={} gpg log: {recorded:?}",
stdout_of(&out),
stderr_of(&out)
);
assert!(!editor_ran.exists(), "editor ran");
create.assert_calls(0);
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn github_release_already_exists_creates_no_tag() {
let root = pending_demo("github-exists");
add_bare_origin(&root);
let server = MockServer::start();
server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.1");
then.status(200).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1",
"tag_name": "v0.1.1"
}));
});
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("already has a release"), "{stderr}");
create.assert_calls(0);
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn current_tag_behind_head_is_resumed() {
let root = temp_git_repo("local-other");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
cargo_package(&root, "demo", "0.1.1");
commit(&root, "version");
git(&root, &["tag", "v0.1.1"]);
fs::write(root.join("later.txt"), "moved").expect("later");
commit(&root, "later");
let tagged = commit_at(&root, "v0.1.1");
add_bare_origin(&root);
let server = MockServer::start();
let lookup = mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
assert!(
!stdout_of(&out).contains("nothing to release"),
"{}",
stdout_of(&out)
);
assert_eq!(lookup.calls(), 1);
create.assert();
assert_eq!(
commit_at(&root, "v0.1.1"),
tagged,
"resuming must release the tag where it stands, not move it"
);
assert_ne!(
git_stdout(&root, &["rev-parse", "v0.1.1^{}"]),
git_stdout(&root, &["rev-parse", "HEAD"])
);
}
#[test]
fn resumes_github_release_when_head_tag_already_exists() {
let root = pending_demo("resume");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
let stdout = stdout_of(&out);
assert!(out.status.success(), "{stdout}{}", stderr_of(&out));
assert!(!stdout.contains("nothing to release"), "{stdout}");
create.assert();
assert!(
stdout.contains("https://github.com/oakoss/oakum/releases/tag/v0.1.1"),
"{stdout}"
);
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
}
#[test]
fn resumes_github_release_when_annotated_head_tag_already_exists() {
let root = pending_demo("resume-annotated");
add_bare_origin(&root);
git(&root, &["tag", "-a", "v0.1.1", "-m", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
let stdout = stdout_of(&out);
assert!(out.status.success(), "{stdout}{}", stderr_of(&out));
assert!(!stdout.contains("nothing to release"), "{stdout}");
create.assert();
assert!(
stdout.contains("https://github.com/oakoss/oakum/releases/tag/v0.1.1"),
"{stdout}"
);
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
}
#[test]
fn existing_github_release_on_head_tag_is_nothing_to_release() {
let root = pending_demo("resume-found");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
let server = MockServer::start();
let lookup = server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.1");
then.status(200).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1",
"tag_name": "v0.1.1"
}));
});
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
assert!(
stdout_of(&out).contains("nothing to release"),
"{}",
stdout_of(&out)
);
lookup.assert();
create.assert_calls(0);
}
#[test]
fn resume_lookup_500_is_unverified_and_creates_no_release() {
let root = pending_demo("resume-500");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
let server = MockServer::start();
server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.1");
then.status(500).body("boom");
});
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
create.assert_calls(0);
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
}
#[test]
fn create_release_500_reports_pushed_and_keeps_the_tag() {
let root = pending_demo("partial");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 500);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("tags are not deleted"), "{stderr}");
assert!(stderr.contains(" v0.1.1 (pushed)"), "{stderr}");
assert!(stderr.contains("remaining:\n v0.1.1"), "{stderr}");
create.assert();
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
let listed = git_stdout(&root, &["ls-remote", "--tags", "origin"]);
assert!(listed.contains("refs/tags/v0.1.1"), "{listed}");
}
#[test]
fn a_release_url_nobody_can_receive_is_not_success() {
let root = pending_demo("dead-stdout");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let writer = support::dead_stdout();
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.stdout(writer)
.output()
.expect("release");
let stderr = stderr_of(&out);
assert_eq!(out.status.code(), Some(2), "{stderr}");
assert_eq!(
stderr.matches("unverified:").count(),
1,
"one verdict, said once: {stderr}"
);
assert!(
stderr.contains("unverified: release stopped; tags are not deleted"),
"{stderr}"
);
assert!(stderr.contains(" v0.1.1 (released)"), "{stderr}");
assert!(
stderr.contains("remaining: none"),
"a released tag is not outstanding: {stderr}"
);
assert!(
stderr.contains("created, but its URL could not be delivered to stdout"),
"{stderr}"
);
create.assert();
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
let listed = git_stdout(&root, &["ls-remote", "--tags", "origin"]);
assert!(listed.contains("refs/tags/v0.1.1"), "{listed}");
}
#[test]
fn the_slug_derives_from_a_github_origin_without_the_env() {
let root = temp_git_repo("slug-derive");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
git(
&root,
&["remote", "add", "origin", "git@github.com:oakoss/demo.git"],
);
let server = MockServer::start();
let lookup = server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/demo/releases/tags/v0.1.0");
then.status(200).json_body(json!({
"html_url": "https://github.com/oakoss/demo/releases/tag/v0.1.0",
"tag_name": "v0.1.0"
}));
});
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env_remove("GITHUB_REPOSITORY")
.output()
.expect("release");
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
assert!(
stdout_of(&out).contains("nothing to release"),
"{}",
stdout_of(&out)
);
lookup.assert();
}
#[cfg(unix)]
#[test]
fn a_blocking_signing_program_meets_the_deadline() {
let root = pending_demo("deadline-signing");
add_bare_origin(&root);
let gpg = sibling(&root, "deadline-signing-gpg");
install_executable(&gpg, String::from("#!/bin/sh\nsleep 60\n"));
git(&root, &["config", "tag.gpgSign", "true"]);
git(
&root,
&["config", "gpg.program", gpg.to_str().expect("utf-8")],
);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let started = std::time::Instant::now();
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.env("OAKUM_REMOTE_DEADLINE", "2")
.output()
.expect("release");
assert!(
started.elapsed() < std::time::Duration::from_secs(30),
"the deadline must bound the signing program's sleep"
);
assert!(!out.status.success(), "a blocked signer must not pass");
let stderr = stderr_of(&out);
assert!(stderr.contains("gave up after 2s"), "{stderr}");
assert!(stderr.contains("signing program"), "{stderr}");
create.assert_calls(0);
}
#[test]
fn a_tag_that_shares_a_branch_name_pushes_the_tag_ref() {
let root = pending_demo("tag-branch-name");
git(&root, &["branch", "v0.1.1"]);
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
let listed = git_stdout(&root, &["ls-remote", "origin"]);
assert!(listed.contains("refs/tags/v0.1.1"), "{listed}");
assert!(
!listed.contains("refs/heads/v0.1.1"),
"the branch must not ride along: {listed}"
);
}
#[cfg(unix)]
#[test]
fn a_push_that_lands_but_dies_reports_pushed() {
let root = pending_demo("push-dies");
add_bare_origin(&root);
let shim_dir = sibling(&root, "push-dies-shim");
fs::create_dir_all(&shim_dir).expect("shim dir");
let real = String::from_utf8(
Command::new("sh")
.args(["-c", "command -v git"])
.output()
.expect("which git")
.stdout,
)
.expect("utf-8");
let shim = shim_dir.join("git");
install_executable(
&shim,
format!(
"#!/bin/sh\nif [ \"$1\" = push ]; then\n {real} \"$@\"\n kill -9 $$\nfi\n\
exec {real} \"$@\"\n",
real = real.trim()
),
);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = oakum_release(&root)
.arg("release")
.env("PATH", path_prefixed_by(&shim_dir))
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.output()
.expect("release");
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains(" v0.1.1 (pushed)"), "{stderr}");
assert!(!stderr.contains("(tagged)"), "{stderr}");
assert!(stderr.contains("terminated by a signal"), "{stderr}");
create.assert_calls(0);
let listed = git_stdout(&root, &["ls-remote", "--tags", "origin"]);
assert!(listed.contains("refs/tags/v0.1.1"), "{listed}");
}
#[cfg(unix)]
#[test]
fn a_dead_push_whose_reread_fails_is_unverified() {
let root = pending_demo("push-dies-blind");
add_bare_origin(&root);
let marker = sibling(&root, "push-dies-blind-marker");
let _ = fs::remove_file(&marker);
let shim_dir = sibling(&root, "push-dies-blind-shim");
fs::create_dir_all(&shim_dir).expect("shim dir");
let real = String::from_utf8(
Command::new("sh")
.args(["-c", "command -v git"])
.output()
.expect("which git")
.stdout,
)
.expect("utf-8");
let shim = shim_dir.join("git");
install_executable(
&shim,
format!(
"#!/bin/sh\ncase \"$1\" in\n\
push) {real} \"$@\"; touch {marker}; kill -9 $$ ;;\n\
ls-remote) if [ -e {marker} ]; then echo 'fatal: down' >&2; exit 128; fi ;;\n\
esac\nexec {real} \"$@\"\n",
real = real.trim(),
marker = marker.display()
),
);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = oakum_release(&root)
.arg("release")
.env("PATH", path_prefixed_by(&shim_dir))
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.output()
.expect("release");
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(
stderr.contains("whether the push landed is unverified"),
"{stderr}"
);
assert!(
stderr.contains("whether the tag landed failed too"),
"the continuation must render without a gap: {stderr}"
);
assert!(!stderr.contains("(tagged)"), "{stderr}");
create.assert_calls(0);
}
#[test]
fn dirty_resume_creates_no_github_release() {
let root = pending_demo("dirty-resume");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
fs::write(root.join("extra.txt"), "dirty").expect("dirty file");
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("dirty"), "{stderr}");
create.assert_calls(0);
}
#[test]
fn pending_sibling_is_not_blocked_by_older_current_tag() {
let root = temp_git_repo("sibling");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.1")]);
commit(&root, "version");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.0");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.0", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create_alpha.assert();
create_beta.assert();
assert_eq!(
commit_at(&root, "alpha/v0.1.0"),
commit_at(&root, "HEAD~1"),
"resuming must release the tag where it stands, not move it"
);
assert!(
local_tags(&root).contains("beta/v0.1.1"),
"{}",
local_tags(&root)
);
}
#[cfg(unix)]
#[test]
fn push_failure_after_tag_reports_tagged() {
let root = pending_demo("push-fail");
let remote = add_bare_origin(&root);
let hook = remote.join("hooks/pre-receive");
install_executable(&hook, "#!/bin/sh\nexit 1\n");
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("v0.1.1 (tagged)"), "{stderr}");
assert!(!stderr.contains("(pushed)"), "{stderr}");
create.assert_calls(0);
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
}
#[test]
fn pending_with_token_and_no_remote_is_unverified() {
let root = pending_demo("no-remote");
let server = MockServer::start();
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("no remotes"), "{stderr}");
create.assert_calls(0);
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn tag_format_whitespace_creates_no_tag() {
let root = pending_demo("ws-fmt");
write_release_config(&root, "tag-format = \"v {{ version }}\"\n");
commit(&root, "config");
add_bare_origin(&root);
let server = MockServer::start();
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("whitespace"), "{stderr}");
create.assert_calls(0);
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn tag_format_invalid_ref_creates_no_tag() {
let root = pending_demo("bad-ref");
write_release_config(&root, "tag-format = \"foo..bar\"\n");
commit(&root, "config");
add_bare_origin(&root);
let server = MockServer::start();
let create = mock_create(&server, "foo..bar", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("invalid git ref"), "{stderr}");
create.assert_calls(0);
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn tag_format_unreadable_shape_creates_no_tag() {
let root = pending_demo("unread-fmt");
write_release_config(&root, "tag-format = \"release-{{ version }}\"\n");
commit(&root, "config");
add_bare_origin(&root);
let server = MockServer::start();
let create = mock_create(&server, "release-0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("leftover"), "{stderr}");
create.assert_calls(0);
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn dirty_worktree_creates_no_tag() {
let root = pending_demo("dirty");
add_bare_origin(&root);
fs::write(root.join("extra.txt"), "dirty").expect("dirty file");
let server = MockServer::start();
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("dirty"), "{stderr}");
create.assert_calls(0);
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn untagged_ahead_plans_the_manifest_version() {
let root = temp_git_repo("untagged");
cargo_package(&root, "demo", "0.2.0");
commit(&root, "init");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.2.0");
let create = mock_create(&server, "v0.2.0", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
assert!(
local_tags(&root).contains("v0.2.0"),
"{}",
local_tags(&root)
);
assert_annotated(&root, "v0.2.0");
}
#[test]
fn tag_format_collision_creates_no_tag() {
let root = temp_git_repo("collide");
write_workspace(&root, &[("alpha", "0.2.0"), ("beta", "0.2.0")]);
write_release_config(&root, "tag-format = \"v{{ version }}\"\n");
commit(&root, "init");
add_bare_origin(&root);
let server = MockServer::start();
let create = mock_create(&server, "v0.2.0", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("more than one package"), "{stderr}");
create.assert_calls(0);
assert!(local_tags(&root).trim().is_empty(), "{}", local_tags(&root));
}
#[test]
fn a_bare_tag_format_over_two_packages_refuses_as_leftover() {
let root = temp_git_repo("bare-leftover");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.2.0")]);
write_release_config(&root, "tag-format = \"v{{ version }}\"\n");
commit(&root, "init");
add_bare_origin(&root);
let server = MockServer::start();
let create = mock_create(&server, "v0.2.0", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(
stderr.contains("tag-format rendered `v0.2.0`, which later check would treat as leftover"),
"the refusal names the tag it rendered: {stderr}"
);
create.assert_calls(0);
assert!(local_tags(&root).trim().is_empty(), "{}", local_tags(&root));
}
#[test]
fn tags_two_packages_one_at_a_time() {
let root = temp_git_repo("two");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.1"), ("beta", "0.1.1")]);
commit(&root, "version");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.1");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.1", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 500);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("alpha/v0.1.1"), "{stderr}");
assert!(stderr.contains("beta/v0.1.1 (pushed)"), "{stderr}");
assert!(stderr.contains("tags are not deleted"), "{stderr}");
create_alpha.assert();
create_beta.assert();
assert!(
local_tags(&root).contains("alpha/v0.1.1"),
"{}",
local_tags(&root)
);
assert!(
local_tags(&root).contains("beta/v0.1.1"),
"{}",
local_tags(&root)
);
assert_annotated(&root, "alpha/v0.1.1");
assert_annotated(&root, "beta/v0.1.1");
}
#[test]
fn both_intent_mechanisms_off_creates_no_tag() {
let root = pending_demo("no-intent");
write_release_config(
&root,
"change-files = false\nconventional-commits = false\n",
);
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(stderr.contains("change-files"), "{stderr}");
assert!(stderr.contains("conventional-commits"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn no_downstream_workflow_is_a_completed_look() {
let root = pending_demo("no-dist");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = server.mock(|when, then| {
when.method(GET).path("/repos/oakoss/oakum/actions/runs");
then.status(200)
.json_body(json!({ "total_count": 0, "workflow_runs": [] }));
});
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
let stderr = stderr_of(&out);
assert!(stderr.contains("no downstream workflow"), "{stderr}");
create.assert();
runs.assert_calls(0);
}
#[test]
fn tag_workflow_run_confirms_the_handoff() {
let root = pending_demo("dist-run");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
],
);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
let stdout = stdout_of(&out);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{stdout}"
);
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn resumed_tag_confirms_the_handoff_at_its_own_commit() {
let root = temp_git_repo("resume-handoff");
cargo_package(&root, "demo", "0.1.0");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
fs::write(root.join("later.txt"), "moved").expect("later");
commit(&root, "later");
add_bare_origin(&root);
let tagged = commit_at(&root, "v0.1.0");
assert_ne!(tagged, head_sha(&root), "the tag must sit behind HEAD");
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.0");
let create = mock_create(&server, "v0.1.0", 201);
let runs = mock_workflow_hits(
&server,
&tagged,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.0",
},
],
);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
assert!(
stdout_of(&out).contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{}",
stdout_of(&out)
);
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn resumed_tag_already_pushed_is_released_where_it_stands() {
let root = temp_git_repo("resume-pushed");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
add_bare_origin(&root);
git(&root, &["push", "origin", "refs/tags/v0.1.0"]);
fs::write(root.join("later.txt"), "moved").expect("later");
commit(&root, "later");
assert_ne!(
commit_at(&root, "v0.1.0"),
head_sha(&root),
"the tag must sit behind HEAD"
);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.0");
let create = mock_create(&server, "v0.1.0", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
}
#[test]
fn mixed_commit_plan_snapshots_each_commit_separately() {
let root = temp_git_repo("mixed-commit-handoff");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.1")]);
commit(&root, "version");
add_bare_origin(&root);
let older = commit_at(&root, "alpha/v0.1.0");
let head = head_sha(&root);
assert_ne!(older, head, "alpha must sit behind HEAD");
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.0");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.0", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
let head_runs = mock_workflow_hits(
&server,
&head,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "beta/v0.1.1",
},
],
);
let older_runs = mock_workflow_hits(
&server,
&older,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "alpha/v0.1.0",
},
],
);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create_alpha.assert();
create_beta.assert();
assert_eq!(
head_runs.iter().map(httpmock::Mock::calls).sum::<usize>(),
2
);
assert_eq!(
older_runs.iter().map(httpmock::Mock::calls).sum::<usize>(),
2
);
}
#[test]
fn second_commit_snapshot_failure_creates_no_release() {
let root = temp_git_repo("snapshot-second-commit");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.1")]);
commit(&root, "version");
add_bare_origin(&root);
let older = commit_at(&root, "alpha/v0.1.0");
let head = head_sha(&root);
assert_ne!(older, head, "alpha must sit behind HEAD");
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.0");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.0", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
mock_workflow_hits(&server, &head, &[RunHit::Empty]);
mock_workflow_hits(&server, &older, &[RunHit::Fail(500)]);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
assert!(
stderr_of(&out).contains("unverified"),
"{}",
stderr_of(&out)
);
create_alpha.assert_calls(0);
create_beta.assert_calls(0);
assert!(
!local_tags(&root).contains("beta/v0.1.1"),
"no tag may be cut before every snapshot is taken: {}",
local_tags(&root)
);
}
#[test]
fn local_tag_on_rewound_history_creates_no_release() {
let root = temp_git_repo("rewound-tag");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
cargo_package(&root, "demo", "0.1.1");
commit(&root, "version");
git(&root, &["tag", "v0.1.1"]);
let abandoned = commit_at(&root, "v0.1.1");
git(&root, &["reset", "--hard", "HEAD~1"]);
cargo_package(&root, "demo", "0.1.1");
commit(&root, "again");
add_bare_origin(&root);
assert_ne!(abandoned, head_sha(&root), "the tag must be off the line");
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
assert!(
stderr_of(&out).contains("local tag `v0.1.1` points at"),
"{}",
stderr_of(&out)
);
create.assert_calls(0);
}
#[test]
fn absorb_scans_every_later_tag_for_a_shared_commit() {
let root = temp_git_repo("interleaved-absorb");
write_workspace(
&root,
&[("alpha", "0.1.0"), ("beta", "0.1.0"), ("gamma", "0.1.0")],
);
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
write_workspace(
&root,
&[("alpha", "0.1.0"), ("beta", "0.1.1"), ("gamma", "0.1.0")],
);
commit(&root, "version");
git(&root, &["tag", "gamma/v0.1.0"]);
add_bare_origin(&root);
let older = commit_at(&root, "alpha/v0.1.0");
let head = head_sha(&root);
assert_ne!(older, head, "alpha must sit behind HEAD");
assert_eq!(
commit_at(&root, "gamma/v0.1.0"),
head,
"gamma must sit at HEAD"
);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.0");
mock_lookup_empty(&server, "gamma%2Fv0.1.0");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.0", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
let create_gamma = mock_create(&server, "gamma/v0.1.0", 201);
let path = ".github/workflows/dist.yml";
mock_workflow_hits(
&server,
&head,
&[
RunHit::Empty,
RunHit::Runs {
ids: vec![100],
path: path.into(),
branch: "beta/v0.1.1",
},
RunHit::Runs {
ids: vec![100, 999],
path: path.into(),
branch: "gamma/v0.1.0",
},
RunHit::Runs {
ids: vec![100, 999, 101],
path: path.into(),
branch: "gamma/v0.1.0",
},
],
);
mock_workflow_hits(
&server,
&older,
&[
RunHit::Empty,
RunHit::Runs {
ids: vec![200],
path: path.into(),
branch: "alpha/v0.1.0",
},
],
);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
let stdout = stdout_of(&out);
create_alpha.assert();
create_beta.assert();
create_gamma.assert();
assert!(stdout.contains("/actions/runs/101"), "{stdout}");
assert!(
!stdout.contains("/actions/runs/999"),
"a run absorbed before this tag was pushed must not confirm it: {stdout}"
);
}
#[test]
fn a_listener_added_after_the_tag_is_no_listener_at_that_commit() {
let root = temp_git_repo("listener-after-tag");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let tagged = commit_at(&root, "v0.1.0");
assert_ne!(tagged, head_sha(&root), "the tag must predate the workflow");
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.0");
let create = mock_create(&server, "v0.1.0", 201);
let runs = mock_workflow_hits(&server, &tagged, &[RunHit::Empty, RunHit::Empty]);
let out = release_cmd(&root, &server);
assert!(out.status.success(), "{}", stderr_of(&out));
let stderr = stderr_of(&out);
assert!(
stderr.contains("no downstream workflow listens for tags"),
"{stderr}"
);
assert!(stderr.contains(&tagged), "{stderr}");
for mock in &runs {
assert_eq!(mock.calls(), 0, "no run can exist there, so none is polled");
}
create.assert();
}
#[test]
fn remote_but_no_token_with_nothing_to_look_at_answers_locally() {
let root = temp_git_repo("remote-no-token");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
add_bare_origin(&root);
let (ok, stdout, stderr) = run_release(&root);
assert!(ok, "a local answer must not refuse: {stdout}{stderr}");
assert!(stdout.contains("nothing to release"), "{stdout}");
}
#[test]
fn missing_tag_workflow_run_is_unverified() {
let root = pending_demo("dist-miss");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_runs(&server, &sha, ".github/workflows/dist.yml", true);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("no workflow run"), "{stderr}");
assert!(stderr.contains("v0.1.1 (released)"), "{stderr}");
assert!(!stderr.contains("remaining:\n v0.1.1"), "{stderr}");
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
create.assert();
runs.assert_calls(2);
}
#[test]
fn dispatch_only_workflow_is_not_triggered() {
let root = pending_demo("dispatch");
write_workflow(
&root,
"dist.yml",
"on:\n workflow_dispatch:\n inputs:\n tag:\n type: string\n",
);
commit(&root, "workflow");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = server.mock(|when, then| {
when.method(GET).path("/repos/oakoss/oakum/actions/runs");
then.status(200)
.json_body(json!({ "total_count": 0, "workflow_runs": [] }));
});
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("workflow_dispatch"), "{stderr}");
assert!(!stderr.contains("unverified"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
create.assert_calls(0);
runs.assert_calls(0);
}
#[test]
fn other_jobs_run_does_not_confirm_the_handoff() {
let root = pending_demo("own-job");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_runs(&server, &sha, ".github/workflows/release.yml", false);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
create.assert();
runs.assert_calls(2);
}
#[test]
fn branch_push_workflow_is_a_completed_look() {
let root = pending_demo("branch-push");
write_workflow(&root, "release.yml", "on: push\n");
commit(&root, "workflow");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = server.mock(|when, then| {
when.method(GET).path("/repos/oakoss/oakum/actions/runs");
then.status(200)
.json_body(json!({ "total_count": 0, "workflow_runs": [] }));
});
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
let stderr = stderr_of(&out);
assert!(stderr.contains("no downstream workflow"), "{stderr}");
create.assert();
runs.assert_calls(0);
}
#[test]
fn later_tag_does_not_reuse_an_earlier_run() {
let root = temp_git_repo("reuse-run");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.1"), ("beta", "0.1.1")]);
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "version");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.1");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.1", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "alpha/v0.1.1",
},
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "alpha/v0.1.1",
},
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "beta/v0.1.1",
},
],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("beta/v0.1.1 (released)"), "{stderr}");
assert!(!stderr.contains("remaining:\n beta/v0.1.1"), "{stderr}");
create_alpha.assert();
create_beta.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 4);
assert!(
local_tags(&root).contains("alpha/v0.1.1"),
"{}",
local_tags(&root)
);
assert!(
local_tags(&root).contains("beta/v0.1.1"),
"{}",
local_tags(&root)
);
}
#[test]
fn later_tag_confirms_a_new_run() {
let root = temp_git_repo("new-run");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.1"), ("beta", "0.1.1")]);
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "version");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.1");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.1", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "alpha/v0.1.1",
},
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "alpha/v0.1.1",
},
RunHit::Run {
id: 10,
path: ".github/workflows/dist.yml".into(),
branch: "beta/v0.1.1",
},
],
);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
let stdout = stdout_of(&out);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{stdout}"
);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/10"),
"{stdout}"
);
create_alpha.assert();
create_beta.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 4);
}
#[test]
fn sibling_listener_run_does_not_confirm_a_later_tag() {
let root = temp_git_repo("sibling-run");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.1"), ("beta", "0.1.1")]);
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
write_workflow(&root, "other.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "version");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.1");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.1", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
let page = RunHit::Page(vec![
(
9,
".github/workflows/dist.yml".into(),
"push",
Some("alpha/v0.1.1"),
),
(
10,
".github/workflows/other.yml".into(),
"push",
Some("beta/v0.1.1"),
),
]);
let runs = mock_workflow_hits(
&server,
&sha,
&[RunHit::Empty, page.clone(), page.clone(), page],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stdout = stdout_of(&out);
let stderr = stderr_of(&out);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{stdout}"
);
assert!(
!stdout.contains("https://github.com/oakoss/oakum/actions/runs/10"),
"{stdout}"
);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("beta/v0.1.1 (released)"), "{stderr}");
create_alpha.assert();
create_beta.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 4);
}
#[test]
fn late_sibling_run_does_not_confirm_a_later_tag() {
let root = temp_git_repo("late-sibling");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.1"), ("beta", "0.1.1")]);
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
write_workflow(&root, "other.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "version");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.1");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.1", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
let page = RunHit::Page(vec![
(
9,
".github/workflows/dist.yml".into(),
"push",
Some("alpha/v0.1.1"),
),
(
10,
".github/workflows/other.yml".into(),
"push",
Some("beta/v0.1.1"),
),
]);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "alpha/v0.1.1",
},
page.clone(),
page,
],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stdout = stdout_of(&out);
let stderr = stderr_of(&out);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{stdout}"
);
assert!(
!stdout.contains("https://github.com/oakoss/oakum/actions/runs/10"),
"{stdout}"
);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("beta/v0.1.1 (released)"), "{stderr}");
create_alpha.assert();
create_beta.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 4);
}
#[test]
fn absorb_500_after_first_confirm_leaves_later_tag() {
let root = temp_git_repo("absorb-500");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.1"), ("beta", "0.1.1")]);
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "version");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.1");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.1", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "alpha/v0.1.1",
},
RunHit::Fail(500),
],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stdout = stdout_of(&out);
let stderr = stderr_of(&out);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{stdout}"
);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("alpha/v0.1.1 (released)"), "{stderr}");
assert!(stderr.contains("remaining:\n beta/v0.1.1"), "{stderr}");
create_alpha.assert();
create_beta.assert_calls(0);
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 3);
}
#[test]
fn absorb_run_without_path_does_not_confirm_a_later_tag() {
let root = temp_git_repo("absorb-no-path");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.1"), ("beta", "0.1.1")]);
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
write_workflow(&root, "other.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "version");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.1");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let create_alpha = mock_create(&server, "alpha/v0.1.1", 201);
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
let allowed = (
9,
Some(".github/workflows/dist.yml".into()),
Some("push"),
None,
);
let later = RunHit::Page(vec![
(
9,
".github/workflows/dist.yml".into(),
"push",
Some("alpha/v0.1.1"),
),
(
10,
".github/workflows/other.yml".into(),
"push",
Some("beta/v0.1.1"),
),
]);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "alpha/v0.1.1",
},
RunHit::Incomplete(vec![allowed, (10, None, Some("push"), None)]),
later,
],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stdout = stdout_of(&out);
let stderr = stderr_of(&out);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{stdout}"
);
assert!(
!stdout.contains("https://github.com/oakoss/oakum/actions/runs/10"),
"{stdout}"
);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("beta/v0.1.1 (released)"), "{stderr}");
create_alpha.assert();
create_beta.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 4);
}
#[test]
fn stale_run_on_head_does_not_confirm() {
let root = pending_demo("stale-run");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_runs(&server, &sha, ".github/workflows/dist.yml", false);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("v0.1.1 (released)"), "{stderr}");
create.assert();
runs.assert_calls(2);
}
#[test]
fn missing_run_path_is_unverified() {
let root = pending_demo("no-path");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::RunWithoutPath { id: 9 },
RunHit::RunWithoutPath { id: 9 },
],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn unreadable_workflow_is_unverified() {
let root = pending_demo("bad-yaml");
write_workflow(&root, "dist.yml", "on: 42\n");
commit(&root, "workflow");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("on: block is not readable"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
create.assert_calls(0);
}
#[test]
fn an_unparseable_workflow_is_refused_by_the_pin_scan_before_the_handoff_look() {
let root = pending_demo("bad-yaml-pin");
write_workflow(&root, "dist.yml", "on: [\n");
commit(&root, "workflow");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(
stderr.contains("unverified: `.github/workflows/dist.yml` is not valid YAML"),
"{stderr}"
);
assert!(
!stderr.contains("on: block is not readable"),
"the pin scan refuses first, once: {stderr}"
);
assert_eq!(local_tags(&root).trim(), "v0.1.0");
create.assert_calls(0);
}
#[test]
fn a_malformed_bump_file_refuses_the_release_by_name() {
let root = pending_demo("malformed-bump");
fs::write(root.join(".changeset/bad.md"), "not a bump file\n").expect("bad");
commit(&root, "bad bump file");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(
stderr.contains("`bad.md` is not a bump file: bump file must start with --- on line 1"),
"{stderr}"
);
assert_eq!(local_tags(&root).trim(), "v0.1.0");
create.assert_calls(0);
}
#[test]
fn a_missing_install_pin_refuses_the_release() {
let root = git_repo("release", "pin-missing");
cargo_package(&root, "demo", "0.1.0");
fs::create_dir_all(root.join(".changeset")).expect("changeset");
fs::write(
root.join(".changeset/_config.toml"),
format!("tool-version = \"{}\"\n", env!("CARGO_PKG_VERSION")),
)
.expect("config");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
cargo_package(&root, "demo", "0.1.1");
commit(&root, "version");
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("no oakum install pin"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
}
#[test]
fn ci_dispatch_button_is_a_completed_look() {
let root = pending_demo("ci-button");
write_workflow(&root, "release.yml", "on: push\n");
write_workflow(
&root,
"ci.yml",
"on:\n pull_request:\n push:\n branches: [main]\n workflow_dispatch:\n",
);
commit(&root, "workflow");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = server.mock(|when, then| {
when.method(GET).path("/repos/oakoss/oakum/actions/runs");
then.status(200)
.json_body(json!({ "total_count": 0, "workflow_runs": [] }));
});
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
let stderr = stderr_of(&out);
assert!(stderr.contains("no downstream workflow"), "{stderr}");
create.assert();
runs.assert_calls(0);
}
#[test]
fn leftover_plus_new_run_confirms() {
let root = pending_demo("leftover-new");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
RunHit::Runs {
ids: vec![9, 10],
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
],
);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
let stdout = stdout_of(&out);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/10"),
"{stdout}"
);
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn confirm_second_look_finds_the_run() {
let root = pending_demo("second-look");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
],
);
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.env("OAKUM_HANDOFF_FAST", "2")
.output()
.expect("release");
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
let stdout = stdout_of(&out);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{stdout}"
);
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 3);
}
#[test]
fn confirm_look_count_does_not_see_a_later_run() {
let root = pending_demo("look-cap");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Empty,
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
],
);
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.env("OAKUM_HANDOFF_FAST", "2")
.output()
.expect("release");
assert!(!out.status.success(), "{}", stdout_of(&out));
let stdout = stdout_of(&out);
let stderr = stderr_of(&out);
assert!(
!stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{stdout}"
);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("after 2 looks"), "{stderr}");
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 3);
}
#[test]
fn snapshot_500_creates_no_tag() {
let root = pending_demo("snap-500");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(&server, &sha, &[RunHit::Fail(500)]);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
create.assert_calls(0);
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 1);
}
#[test]
fn tag_listener_plus_dispatch_sibling_confirms() {
let root = pending_demo("sibling-dispatch");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
write_workflow(
&root,
"manual.yml",
"on:\n workflow_dispatch:\n inputs: {}\n",
);
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
],
);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn confirm_500_after_release_reports_released() {
let root = pending_demo("confirm-500");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(&server, &sha, &[RunHit::Empty, RunHit::Fail(500)]);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("v0.1.1 (released)"), "{stderr}");
assert_eq!(
stderr.matches("v0.1.1").count(),
1,
"the tag must be named once, at one stage: {stderr}"
);
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn dispatch_event_does_not_confirm() {
let root = pending_demo("dispatch-event");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Event {
id: 9,
path: ".github/workflows/dist.yml".into(),
event: "workflow_dispatch",
branch: None,
},
],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn create_event_confirms_the_handoff() {
let root = pending_demo("create-event");
write_workflow(&root, "dist.yml", "on: create\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Event {
id: 9,
path: ".github/workflows/dist.yml".into(),
event: "create",
branch: Some("v0.1.1"),
},
],
);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
let stdout = stdout_of(&out);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{stdout}"
);
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn pull_request_event_does_not_confirm() {
let root = pending_demo("pr-event");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Event {
id: 9,
path: ".github/workflows/dist.yml".into(),
event: "pull_request",
branch: None,
},
],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn tags_ignore_workflow_confirms_the_handoff() {
let root = pending_demo("tags-ignore");
write_workflow(
&root,
"dist.yml",
"on:\n push:\n tags-ignore:\n - '*-dev'\n",
);
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Empty,
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
],
);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
let stdout = stdout_of(&out);
assert!(
stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"{stdout}"
);
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn leftover_run_does_not_confirm_a_tag_this_invocation_never_pushed() {
let root = pending_demo("resume-leftover");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
git(&root, &["tag", "-d", "v0.1.1"]);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stdout = stdout_of(&out);
let stderr = stderr_of(&out);
assert!(
!stdout.contains("https://github.com/oakoss/oakum/actions/runs/9"),
"a pre-existing run must not be reported as this tag's handoff: {stdout}"
);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("pushed nothing"), "{stderr}");
assert!(stderr.contains("v0.1.1 (released)"), "{stderr}");
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 1);
}
#[test]
fn leftover_without_path_does_not_confirm_when_path_appears() {
let root = pending_demo("leftover-no-path");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::RunWithoutPath { id: 9 },
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("v0.1.1 (released)"), "{stderr}");
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn snapshot_304_creates_no_tag() {
let root = pending_demo("snap-304");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(&server, &sha, &[RunHit::Fail(304)]);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("not fresh"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
create.assert_calls(0);
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 1);
}
#[test]
fn leftover_without_event_does_not_confirm_when_event_appears() {
let root = pending_demo("leftover-no-event");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(
&server,
&sha,
&[
RunHit::RunWithoutEvent {
id: 9,
path: ".github/workflows/dist.yml".into(),
},
RunHit::Run {
id: 9,
path: ".github/workflows/dist.yml".into(),
branch: "v0.1.1",
},
],
);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("v0.1.1 (released)"), "{stderr}");
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn confirm_304_after_release_is_unverified() {
let root = pending_demo("confirm-304");
write_workflow(&root, "dist.yml", "on:\n push:\n tags:\n - '*'\n");
commit(&root, "workflow");
add_bare_origin(&root);
let sha = head_sha(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let runs = mock_workflow_hits(&server, &sha, &[RunHit::Empty, RunHit::Fail(304)]);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("v0.1.1 (released)"), "{stderr}");
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
create.assert();
assert_eq!(runs.iter().map(httpmock::Mock::calls).sum::<usize>(), 2);
}
#[test]
fn a_tag_on_unreachable_history_is_unverified_not_nothing() {
let root = temp_git_repo("unreachable-tag");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
fs::write(root.join("second.txt"), "x").expect("second");
commit(&root, "second");
git(&root, &["tag", "v0.1.0"]);
git(&root, &["reset", "--hard", "HEAD~1"]);
git(&root, &["branch", "v0.1.0"]);
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(!stdout.contains("nothing to release"), "{stdout}");
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("unreachable"), "{stderr}");
assert!(stderr.contains("`v0.1.0`"), "{stderr}");
}
#[test]
fn a_remote_only_tag_is_unverified_not_nothing() {
let root = temp_git_repo("remote-only-tag");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
add_bare_origin(&root);
git(&root, &["push", "origin", "refs/tags/v0.1.0"]);
git(&root, &["tag", "-d", "v0.1.0"]);
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(!stdout.contains("nothing to release"), "{stdout}");
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("exists on remote"), "{stderr}");
assert!(stderr.contains("git fetch"), "{stderr}");
}
#[test]
fn a_tag_format_drifted_from_the_existing_tag_is_unverified_not_nothing() {
let root = temp_git_repo("drifted-tag");
cargo_package(&root, "demo", "0.1.0");
write_release_config(&root, "tag-format = \"release-{{ version }}\"\n");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(!stdout.contains("nothing to release"), "{stdout}");
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("`release-0.1.0`"), "{stderr}");
assert!(stderr.contains("`v0.1.0`"), "{stderr}");
}
#[test]
fn an_unpublishable_package_is_not_pending_without_tag_opt_in() {
let root = temp_git_repo("private-no-tag");
fs::write(
root.join("Cargo.toml"),
"[package]\nname = \"internal\"\nversion = \"0.2.0\"\nedition = \"2021\"\npublish = false\n\n[workspace]\n",
)
.expect("Cargo.toml");
fs::create_dir_all(root.join("src")).expect("src");
fs::write(root.join("src/lib.rs"), "").expect("lib.rs");
write_release_config(&root, "");
commit(&root, "init");
let (ok, stdout, stderr) = run_release(&root);
assert!(ok, "{stdout}{stderr}");
assert!(stdout.contains("nothing to release"), "{stdout}");
}
#[test]
fn an_unpublishable_package_is_pending_when_private_packages_tag_is_true() {
let root = temp_git_repo("private-tag-opt-in");
fs::write(
root.join("Cargo.toml"),
"[package]\nname = \"internal\"\nversion = \"0.2.0\"\nedition = \"2021\"\npublish = false\n\n[workspace]\n",
)
.expect("Cargo.toml");
fs::create_dir_all(root.join("src")).expect("src");
fs::write(root.join("src/lib.rs"), "").expect("lib.rs");
write_release_config(&root, "[private-packages]\ntag = true\n");
commit(&root, "init");
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(!stdout.contains("nothing to release"), "{stdout}");
assert!(
stderr.contains("no remotes") || stderr.contains("never released"),
"{stderr}"
);
}
#[test]
fn include_one_package_uses_bare_tag_names() {
let root = temp_git_repo("include-uses-bare");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
write_release_config(&root, "include = [\"alpha\"]\n");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.1"), ("beta", "0.1.0")]);
commit(&root, "version");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create_bare = mock_create(&server, "v0.1.1", 201);
let create_alpha = mock_create(&server, "alpha/v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create_bare.assert();
create_alpha.assert_calls(0);
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
}
#[test]
fn unpublishable_sibling_uses_bare_tag_names() {
let root = temp_git_repo("unpublishable-uses-bare");
write_workspace(&root, &[("alpha", "0.1.0"), ("probe", "0.1.0")]);
fs::write(
root.join("probe/Cargo.toml"),
"[package]\nname = \"probe\"\nversion = \"0.1.0\"\nedition = \"2021\"\npublish = false\n",
)
.expect("probe manifest");
write_release_config(&root, "");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.1"), ("probe", "0.1.0")]);
fs::write(
root.join("probe/Cargo.toml"),
"[package]\nname = \"probe\"\nversion = \"0.1.0\"\nedition = \"2021\"\npublish = false\n",
)
.expect("probe manifest");
commit(&root, "version");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create_bare = mock_create(&server, "v0.1.1", 201);
let create_prefixed = mock_create(&server, "alpha/v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create_bare.assert();
create_prefixed.assert_calls(0);
assert!(
local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
}
#[test]
fn an_excluded_package_is_not_pending_for_release() {
let root = temp_git_repo("exclude-not-pending");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
write_release_config(&root, "exclude = [\"beta\"]\n");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.1")]);
commit(&root, "bump beta only");
add_bare_origin(&root);
git(&root, &["push", "origin", "refs/tags/v0.1.0"]);
let server = MockServer::start();
let lookup = server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.0");
then.status(200).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.0",
"tag_name": "v0.1.0"
}));
});
let create_beta = mock_create(&server, "beta/v0.1.1", 201);
let create_bare = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
assert!(
stdout_of(&out).contains("nothing to release"),
"{}",
stdout_of(&out)
);
lookup.assert();
create_beta.assert_calls(0);
create_bare.assert_calls(0);
}
#[test]
fn an_unpublishable_packages_stray_tag_does_not_refuse_the_release() {
let root = temp_git_repo("private-stray-tag");
write_workspace(
&root,
&[("alpha", "0.1.0"), ("beta", "0.1.0"), ("internal", "0.1.0")],
);
fs::write(
root.join("internal/Cargo.toml"),
"[package]\nname = \"internal\"\nversion = \"0.1.0\"\nedition = \"2021\"\npublish = false\n",
)
.expect("private manifest");
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
git(&root, &["checkout", "-q", "--detach", "HEAD"]);
git(&root, &["commit", "--allow-empty", "-m", "stray"]);
git(&root, &["tag", "internal/v0.1.0"]);
git(&root, &["checkout", "-q", "main"]);
add_bare_origin(&root);
let server = MockServer::start();
for tag in ["alpha%2Fv0.1.0", "beta%2Fv0.1.0"] {
server.mock(|when, then| {
when.method(GET)
.path(format!("/repos/oakoss/oakum/releases/tags/{tag}"));
then.status(200).json_body(json!({
"html_url": format!("https://github.com/oakoss/oakum/releases/tag/{tag}"),
"tag_name": tag
}));
});
}
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
assert!(
stdout_of(&out).contains("nothing to release"),
"{}",
stdout_of(&out)
);
}
#[test]
fn a_remote_only_tag_under_an_earlier_format_is_unverified_not_nothing() {
let root = temp_git_repo("remote-old-format-tag");
cargo_package(&root, "demo", "0.1.0");
write_release_config(&root, "tag-format = \"release-{{ version }}\"\n");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
add_bare_origin(&root);
git(&root, &["push", "origin", "refs/tags/v0.1.0"]);
git(&root, &["tag", "-d", "v0.1.0"]);
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(!stdout.contains("nothing to release"), "{stdout}");
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("`v0.1.0`"), "{stderr}");
assert!(stderr.contains("release-0.1.0"), "{stderr}");
}
#[test]
fn a_local_unattributable_unreachable_tag_is_unverified_not_nothing() {
let root = temp_git_repo("local-leftover-tag");
write_workspace(&root, &[("beta", "0.1.0"), ("zeta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "zeta-v0.1.0"]);
fs::write(root.join("stray.txt"), "x").expect("stray");
commit(&root, "stray");
git(&root, &["tag", "v0.1.0"]);
git(&root, &["reset", "--hard", "HEAD~1"]);
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(!stdout.contains("nothing to release"), "{stdout}");
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("`v0.1.0`"), "{stderr}");
assert!(stderr.contains("could not be attributed"), "{stderr}");
}
#[test]
fn an_unattributable_remote_tag_is_unverified_not_nothing() {
let root = temp_git_repo("remote-leftover-tag");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
add_bare_origin(&root);
git(&root, &["push", "origin", "refs/tags/v0.1.0"]);
git(&root, &["tag", "-d", "v0.1.0"]);
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(!stdout.contains("nothing to release"), "{stdout}");
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("`v0.1.0`"), "{stderr}");
assert!(stderr.contains("could not be attributed"), "{stderr}");
}
#[test]
fn a_shallow_clone_refuses_before_the_unread_tags_scan() {
let root = temp_git_repo("shallow-release");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
fs::write(root.join("second.txt"), "x").expect("second");
commit(&root, "second");
git(&root, &["tag", "v0.1.0"]);
let clone = sibling(&root, "shallow");
git(
&root,
&[
"-c",
"protocol.file.allow=always",
"clone",
"--depth=1",
"--no-tags",
"--no-local",
root.to_str().expect("utf-8"),
clone.to_str().expect("utf-8"),
],
);
let (ok, stdout, stderr) = run_release(&clone);
assert!(!ok, "{stdout}{stderr}");
assert!(stderr.contains("shallow"), "{stderr}");
assert!(
!stderr.contains("unreachable"),
"a shallow clone must refuse as shallow, not misread its empty \
listing as unreachable tags: {stderr}"
);
}
#[test]
fn a_corrupt_tag_object_is_unverified_not_nothing() {
let root = temp_git_repo("corrupt-tag");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "-a", "-m", "v0.1.0", "v0.1.0"]);
let object = git_stdout(&root, &["rev-parse", "refs/tags/v0.1.0"]);
fs::remove_file(
root.join(".git/objects")
.join(&object[..2])
.join(&object[2..]),
)
.expect("delete tag object");
let (ok, stdout, stderr) = run_release(&root);
assert!(!ok, "{stdout}{stderr}");
assert!(!stdout.contains("nothing to release"), "{stdout}");
assert!(stderr.contains("unverified"), "{stderr}");
assert!(stderr.contains("cannot be read"), "{stderr}");
assert!(stderr.contains(&object), "{stderr}");
}
fn mock_lookup_empty<'a>(server: &'a MockServer, encoded_tag: &str) -> httpmock::Mock<'a> {
server.mock(|when, then| {
when.method(GET)
.path(format!("/repos/oakoss/oakum/releases/tags/{encoded_tag}"));
then.status(404).body("Not Found");
})
}
fn mock_create<'a>(server: &'a MockServer, tag: &str, status: u16) -> httpmock::Mock<'a> {
let body = format!("\"tag_name\":\"{tag}\"");
let url = format!("https://github.com/oakoss/oakum/releases/tag/{tag}");
server.mock(|when, then| {
when.method(POST)
.path("/repos/oakoss/oakum/releases")
.body_includes(body);
then.status(status).json_body(json!({ "html_url": url }));
})
}
fn release_cmd(root: &Path, server: &MockServer) -> std::process::Output {
oakum_release(root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.output()
.expect("release")
}
fn stdout_of(out: &std::process::Output) -> String {
String::from_utf8_lossy(&out.stdout).into_owned()
}
fn stderr_of(out: &std::process::Output) -> String {
String::from_utf8_lossy(&out.stderr).into_owned()
}
fn write_release_config(root: &Path, extra: &str) {
pinned_config(root);
let version = env!("CARGO_PKG_VERSION");
fs::write(
root.join(".changeset/_config.toml"),
format!("tool-version = \"{version}\"\n{extra}"),
)
.expect("config");
}
fn write_workspace(root: &Path, members: &[(&str, &str)]) {
let listed = members
.iter()
.map(|(name, _)| format!("\"{name}\""))
.collect::<Vec<_>>()
.join(", ");
fs::write(
root.join("Cargo.toml"),
format!("[workspace]\nresolver = \"2\"\nmembers = [{listed}]\n"),
)
.expect("workspace");
for (name, version) in members {
let dir = root.join(name);
fs::create_dir_all(dir.join("src")).expect("src");
fs::write(
dir.join("Cargo.toml"),
format!("[package]\nname = \"{name}\"\nversion = \"{version}\"\nedition = \"2021\"\n"),
)
.expect("member Cargo.toml");
fs::write(dir.join("src/lib.rs"), "").expect("lib.rs");
}
}
#[cfg(unix)]
fn local_ssh_transport(root: &Path, bare: &Path, log: &Path) -> PathBuf {
let script = root.join("fake-ssh");
install_executable(
&script,
format!(
"#!/bin/sh\nargs=\"$*\"\nfor a in \"$@\"; do last=$a; done\n\
for a in \"$@\"; do [ \"$a\" = -G ] && {{ printf 'probe :: %s\\n' \"$args\" >> {log}; exit 0; }}; done\n\
verb=${{last%% *}}\nprintf '%s :: %s\\n' \"$verb\" \"$args\" >> {log}\n\
exec git \"${{verb#git-}}\" {bare}\n",
log = log.display(),
bare = bare.display()
),
);
script
}
#[cfg(unix)]
#[test]
fn the_tag_push_refuses_prompts() {
let root = pending_demo("push-batchmode");
let bare = sibling(&root, "push-batchmode.git");
git(&root, &["init", "--bare", bare.to_str().expect("utf-8")]);
git(
&root,
&[
"remote",
"add",
"origin",
"git@example.invalid:demo/demo.git",
],
);
let log = sibling(&root, "push-batchmode-ssh.log");
let _ = fs::remove_file(&log);
let script = local_ssh_transport(root.container(), &bare, &log);
let server = MockServer::start();
server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.1");
then.status(404).body("Not Found");
});
let create = server.mock(|when, then| {
when.method(POST).path("/repos/oakoss/oakum/releases");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1"
}));
});
let out = oakum_release(&root)
.arg("release")
.env("GITHUB_TOKEN", "token")
.env("GITHUB_API_URL", server.base_url())
.env("GITHUB_REPOSITORY", "oakoss/oakum")
.env("GIT_SSH_COMMAND", script.to_str().expect("utf-8"))
.output()
.expect("release");
assert!(
out.status.success(),
"stdout={} stderr={}",
String::from_utf8_lossy(&out.stdout),
String::from_utf8_lossy(&out.stderr)
);
create.assert();
let recorded = fs::read_to_string(&log).unwrap_or_default();
let push = recorded
.lines()
.find(|line| line.starts_with("git-receive-pack ::"))
.unwrap_or_else(|| panic!("no push reached the transport; recorded: {recorded:?}"));
assert!(
push.contains("-o BatchMode=yes"),
"the tag push can still stop at an ssh prompt; recorded: {push:?}"
);
}
#[test]
fn skip_ci_in_the_commit_body_creates_no_tag() {
let root = temp_git_repo("skip-body");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
cargo_package(&root, "demo", "0.1.1");
git(&root, &["add", "-A"]);
git(
&root,
&[
"commit",
"--no-verify",
"-m",
"chore: release demo 0.1.1",
"-m",
"[skip ci]",
],
);
add_bare_origin(&root);
let server = MockServer::start();
let lookup = mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
let stderr = stderr_of(&out);
assert!(!out.status.success(), "{stderr}");
assert!(stderr.contains("skip-ci"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
lookup.assert_calls(1);
create.assert_calls(0);
}
#[test]
fn the_trailer_oracle_corpus_still_refuses_on_real_commits() {
for (label, message) in [
("padded", "chore: release demo 0.1.1\n\nskip-checks: True"),
(
"mixed",
"chore: release demo 0.1.1\n\nbody text\nSigned-off-by: a\nskip-checks: true",
),
("folded", "chore: release demo 0.1.1\n\nskip-checks:\n true"),
] {
let root = temp_git_repo(&format!("trailer-{label}"));
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
cargo_package(&root, "demo", "0.1.1");
git(&root, &["add", "-A"]);
git(
&root,
&["commit", "--no-verify", "--cleanup=verbatim", "-m", message],
);
add_bare_origin(&root);
let server = MockServer::start();
let lookup = mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
let stderr = stderr_of(&out);
assert!(!out.status.success(), "{label}: {stderr}");
assert!(stderr.contains("skip-ci"), "{label}: {stderr}");
lookup.assert_calls(1);
create.assert_calls(0);
}
}
#[test]
fn skip_checks_trailer_on_a_real_commit_creates_no_tag() {
let root = temp_git_repo("skip-trailer");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
cargo_package(&root, "demo", "0.1.1");
git(&root, &["add", "-A"]);
git(
&root,
&[
"commit",
"--no-verify",
"-m",
"chore: release demo 0.1.1",
"-m",
"skip-checks: true",
],
);
add_bare_origin(&root);
let server = MockServer::start();
let lookup = mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
let stderr = stderr_of(&out);
assert!(!out.status.success(), "{stderr}");
assert!(stderr.contains("skip-ci"), "{stderr}");
assert_eq!(local_tags(&root).trim(), "v0.1.0");
lookup.assert_calls(1);
create.assert_calls(0);
}
#[test]
fn a_foreign_changelog_title_does_not_stop_a_release() {
let root = pending_demo("body-foreign-title");
fs::write(
root.join("CHANGELOG.md"),
"# @scope/demo\n\n## 0.1.1 (2026-09-08)\n\n### Fixed\n\n- a fix\n\n## 0.1.0 (2026-09-01)\n\n- first\n",
)
.expect("changelog");
commit(&root, "changelog");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
git(&root, &["tag", "-d", "v0.1.1"]);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = server.mock(|when, then| {
when.method(POST)
.path("/repos/oakoss/oakum/releases")
.body_includes("\"body\":\"### Fixed\\n\\n- a fix\\n\"");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1"
}));
});
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"release reads the section under any title; only version refuses: {}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
assert!(
!stderr_of(&out).contains("does not start with"),
"{}",
stderr_of(&out)
);
}
#[test]
fn release_body_is_the_changelog_section_for_the_version() {
let root = pending_demo("body-from-changelog");
fs::write(
root.join("CHANGELOG.md"),
"# Changelog\n\n## 0.1.1 (2026-09-08)\n\n### Fixed\n\n- a fix\n\n## 0.1.0 (2026-09-01)\n\n- first\n\nGenerated by oakum 0.1.4.\n",
)
.expect("changelog");
commit(&root, "changelog");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
git(&root, &["tag", "-d", "v0.1.1"]);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = server.mock(|when, then| {
when.method(POST)
.path("/repos/oakoss/oakum/releases")
.body_includes("\"body\":\"### Fixed\\n\\n- a fix\\n\"");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1"
}));
});
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
assert!(
!stdout_of(&out).contains("release body:"),
"{}",
stdout_of(&out)
);
}
#[test]
fn release_body_falls_back_to_the_title_and_says_so() {
let root = pending_demo("body-no-changelog");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
git(&root, &["tag", "-d", "v0.1.1"]);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = server.mock(|when, then| {
when.method(POST)
.path("/repos/oakoss/oakum/releases")
.body_includes("\"body\":\"demo 0.1.1\\n\"");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1"
}));
});
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
let stderr = stderr_of(&out);
assert!(
stderr.contains("release body: no CHANGELOG.md at ")
&& stderr.contains("; using the title"),
"{stderr}"
);
assert!(
!stdout_of(&out).contains("release body:"),
"{}",
stdout_of(&out)
);
}
fn mock_create_with_body<'a>(server: &'a MockServer, body_fragment: &str) -> httpmock::Mock<'a> {
let needle = format!("\"body\":\"{body_fragment}\"");
server.mock(|when, then| {
when.method(POST)
.path("/repos/oakoss/oakum/releases")
.body_includes(needle);
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1"
}));
})
}
#[test]
fn resumed_release_body_comes_from_the_tagged_commit() {
let root = pending_demo("body-resumed");
fs::write(
root.join("CHANGELOG.md"),
"# Changelog\n\n## 0.1.1 (2026-09-08)\n\n- from the tag\n",
)
.expect("changelog");
commit(&root, "changelog");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
fs::write(
root.join("CHANGELOG.md"),
"# Changelog\n\n## 0.1.1 (2026-09-08)\n\n- rewritten after the tag\n",
)
.expect("changelog");
commit(&root, "later edit");
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create_with_body(&server, "- from the tag\\n");
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
}
#[test]
fn empty_section_falls_back_to_the_title_and_says_so() {
let root = pending_demo("body-empty-section");
fs::write(
root.join("CHANGELOG.md"),
"# Changelog\n\n## 0.1.1 (2026-09-08)\n\n## 0.1.0 (2026-09-01)\n\n- first\n",
)
.expect("changelog");
commit(&root, "changelog");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
git(&root, &["tag", "-d", "v0.1.1"]);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create_with_body(&server, "demo 0.1.1\\n");
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
assert!(
stderr_of(&out)
.contains("release body: CHANGELOG.md has an empty 0.1.1 section; using the title"),
"{}",
stderr_of(&out)
);
}
#[test]
fn prerelease_body_matches_its_own_section() {
let root = temp_git_repo("body-prerelease");
cargo_package(&root, "demo", "0.1.0");
commit(&root, "init");
git(&root, &["tag", "v0.1.0"]);
cargo_package(&root, "demo", "0.1.1-rc.1");
fs::write(
root.join("CHANGELOG.md"),
"# Changelog\n\n## 0.1.1-rc.1 (2026-09-08)\n\n- rc note\n\n## 0.1.0 (2026-09-01)\n\n- first\n",
)
.expect("changelog");
commit(&root, "version");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1-rc.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1-rc.1"]);
git(&root, &["tag", "-d", "v0.1.1-rc.1"]);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1-rc.1");
let create = server.mock(|when, then| {
when.method(POST)
.path("/repos/oakoss/oakum/releases")
.body_includes("\"body\":\"- rc note\\n\"");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1-rc.1"
}));
});
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
}
#[test]
fn member_changelog_is_read_from_the_member_directory() {
let root = temp_git_repo("body-member");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
commit(&root, "init");
git(&root, &["tag", "alpha/v0.1.0"]);
git(&root, &["tag", "beta/v0.1.0"]);
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.1")]);
fs::write(
root.join("beta/CHANGELOG.md"),
"# Changelog\n\n## 0.1.1 (2026-09-08)\n\n- member fix\n",
)
.expect("changelog");
fs::write(
root.join("CHANGELOG.md"),
"# Changelog\n\n## 0.1.1 (2026-09-08)\n\n- WRONG root file\n",
)
.expect("root changelog");
commit(&root, "version");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%2Fv0.1.0");
mock_lookup_empty(&server, "beta%2Fv0.1.1");
let _create_alpha = mock_create(&server, "alpha/v0.1.0", 201);
let create = server.mock(|when, then| {
when.method(POST)
.path("/repos/oakoss/oakum/releases")
.body_includes("\"body\":\"- member fix\\n\"");
then.status(201).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/beta/v0.1.1"
}));
});
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
}
#[test]
fn a_changelog_blob_that_is_not_utf8_refuses_before_tagging() {
let root = pending_demo("body-not-utf8");
fs::write(
root.join("CHANGELOG.md"),
b"# Changelog\n\n## 0.1.1\n\n\xe9\xff\xfe\n",
)
.expect("changelog");
commit(&root, "changelog");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(!out.status.success(), "{}", stdout_of(&out));
let stderr = stderr_of(&out);
assert!(
stderr.contains("could not read CHANGELOG.md at ")
&& stderr.contains("not valid UTF-8")
&& stderr.contains("no tag was created")
&& !stderr.contains("unverified"),
"{stderr}"
);
create.assert_calls(0);
assert!(
!local_tags(&root).contains("v0.1.1"),
"{}",
local_tags(&root)
);
}
#[test]
fn a_fenced_shell_comment_does_not_end_the_release_body() {
let root = pending_demo("body-fenced");
fs::write(
root.join("CHANGELOG.md"),
"# Changelog\n\n## 0.1.1 (2026-09-08)\n\nInstall it:\n\n```sh\n# grab the binary\ncargo install oakum\n```\n\nThen run it.\n\n## 0.1.0\n\n- first\n",
)
.expect("changelog");
commit(&root, "changelog");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create_with_body(
&server,
"Install it:\\n\\n```sh\\n# grab the binary\\ncargo install oakum\\n```\\n\\nThen run it.\\n",
);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
assert!(
!stderr_of(&out).contains("release body:"),
"{}",
stderr_of(&out)
);
}
#[test]
fn a_trailing_hard_break_survives_into_the_release_body() {
let root = pending_demo("body-hard-break");
fs::write(
root.join("CHANGELOG.md"),
"# Changelog\n\n## 0.1.1 (2026-09-08)\n\nline one \nline two\n",
)
.expect("changelog");
commit(&root, "changelog");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create_with_body(&server, "line one \\nline two\\n");
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
}
#[test]
fn a_resumed_tag_with_its_release_already_created_never_reads_its_changelog() {
let root = pending_demo("body-already-released");
fs::write(
root.join("CHANGELOG.md"),
b"# Changelog\n\n## 0.1.1\n\n\xe9\xff\xfe\n",
)
.expect("changelog");
commit(&root, "changelog");
add_bare_origin(&root);
git(&root, &["tag", "v0.1.1"]);
git(&root, &["push", "origin", "refs/tags/v0.1.1"]);
let server = MockServer::start();
let lookup = server.mock(|when, then| {
when.method(GET)
.path("/repos/oakoss/oakum/releases/tags/v0.1.1");
then.status(200).json_body(json!({
"html_url": "https://github.com/oakoss/oakum/releases/tag/v0.1.1",
"tag_name": "v0.1.1"
}));
});
let create = mock_create(&server, "v0.1.1", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
assert!(
stdout_of(&out).contains("nothing to release"),
"{}",
stdout_of(&out)
);
lookup.assert_calls(1);
create.assert_calls(0);
}
#[cfg(unix)]
#[test]
fn a_symlinked_changelog_is_named_in_the_fallback_notice() {
let root = pending_demo("body-symlink");
fs::write(
root.join("CHANGELOG.real.md"),
"# Changelog\n\n## 0.1.1 (2026-09-08)\n\n- behind the link\n",
)
.expect("real changelog");
std::os::unix::fs::symlink("CHANGELOG.real.md", root.join("CHANGELOG.md")).expect("symlink");
commit(&root, "changelog");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create_with_body(&server, "demo 0.1.1\\n");
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
let stderr = stderr_of(&out);
assert!(
stderr.contains("release body: CHANGELOG.md at ")
&& stderr.contains(" is a symlink to `CHANGELOG.real.md`; using the title"),
"{stderr}"
);
}
#[test]
fn a_missing_heading_falls_back_to_the_title_and_names_the_next_step() {
let root = pending_demo("body-no-heading");
fs::write(
root.join("CHANGELOG.md"),
"# Changelog\n\n## 0.1.0 (2026-09-01)\n\n- first\n",
)
.expect("changelog");
commit(&root, "changelog");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "v0.1.1");
let create = mock_create_with_body(&server, "demo 0.1.1\\n");
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create.assert();
assert!(
stderr_of(&out).contains(
"release body: CHANGELOG.md has no `## 0.1.1` heading; using the title (run `oakum version` before releasing, or add the section)"
),
"{}",
stderr_of(&out)
);
}
#[test]
fn a_package_bearing_tag_format_cuts_a_tag_for_each_package() {
let root = temp_git_repo("package-at-version");
write_workspace(&root, &[("alpha", "0.1.0"), ("beta", "0.1.0")]);
write_release_config(&root, "tag-format = \"{{ package }}@{{ version }}\"\n");
commit(&root, "init");
git(&root, &["tag", "alpha@0.1.0"]);
git(&root, &["tag", "beta@0.1.0"]);
write_workspace(&root, &[("alpha", "0.2.0"), ("beta", "0.3.0")]);
commit(&root, "version");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "alpha%400.2.0");
mock_lookup_empty(&server, "beta%400.3.0");
let create_alpha = mock_create(&server, "alpha@0.2.0", 201);
let create_beta = mock_create(&server, "beta@0.3.0", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create_alpha.assert();
create_beta.assert();
let tags = local_tags(&root);
assert!(tags.contains("alpha@0.2.0"), "{tags}");
assert!(tags.contains("beta@0.3.0"), "{tags}");
assert_annotated(&root, "alpha@0.2.0");
assert_annotated(&root, "beta@0.3.0");
}
#[test]
fn an_all_private_workspace_tags_every_member_on_the_tag_axis() {
let root = temp_git_repo("private-monorepo-release");
let members = [("pr-kit", "0.1.0"), ("prose", "0.1.0")];
private_workspace(&root, &members);
write_release_config(
&root,
"tag-format = \"{{ package }}@{{ version }}\"\n[private-packages]\ntag = true\n",
);
commit(&root, "init");
tag_members_at_version(&root, &members);
private_workspace(&root, &[("pr-kit", "0.2.0"), ("prose", "0.3.0")]);
commit(&root, "version");
add_bare_origin(&root);
let server = MockServer::start();
mock_lookup_empty(&server, "pr-kit%400.2.0");
mock_lookup_empty(&server, "prose%400.3.0");
let create_kit = mock_create(&server, "pr-kit@0.2.0", 201);
let create_prose = mock_create(&server, "prose@0.3.0", 201);
let out = release_cmd(&root, &server);
assert!(
out.status.success(),
"{}{}",
stdout_of(&out),
stderr_of(&out)
);
create_kit.assert();
create_prose.assert();
let tags = local_tags(&root);
assert!(tags.contains("pr-kit@0.2.0"), "{tags}");
assert!(tags.contains("prose@0.3.0"), "{tags}");
assert_annotated(&root, "pr-kit@0.2.0");
assert_annotated(&root, "prose@0.3.0");
}