john-slop/tests/release_wrapper.rs

124 lines
4.7 KiB
Rust

#![cfg(unix)]
use std::{
env, fs,
os::unix::fs::PermissionsExt,
path::Path,
process::{Command, Output},
};
use tempfile::TempDir;
const DEVELOPMENT_ORIGIN: &str = "git@git.dandaedre.com:idle-org/john-slop.git";
const RELEASE_CONFIG: &str = "[[repository.fallbacks]]\n\
origin = \"git@git.dandaedre.com:idle-org/john-slop.git\"\n\
fallback-url = \"https://proxy.dandaedre.com/gitea/idle-org/john-slop\"\n";
fn run(command: &mut Command) -> Output {
command.output().expect("test command should start")
}
fn git(repository: &Path, arguments: &[&str]) -> Output {
run(Command::new("git")
.arg("-C")
.arg(repository)
.args(arguments))
}
#[test]
fn release_wrapper_uses_repository_fallback_without_changing_origin() {
for release_status in [0, 17] {
let temporary = TempDir::new().expect("temporary directory should be created");
let repository = temporary.path().join("repository");
let fake_bin = temporary.path().join("bin");
fs::create_dir_all(&repository).expect("repository directory should be created");
fs::create_dir_all(&fake_bin).expect("fake binary directory should be created");
fs::copy(
Path::new(env!("CARGO_MANIFEST_DIR")).join("release.sh"),
repository.join("release.sh"),
)
.expect("release wrapper should be copied");
fs::copy(
Path::new(env!("CARGO_MANIFEST_DIR")).join("rust-release.toml"),
repository.join("rust-release.toml"),
)
.expect("release configuration should be copied");
fs::write(
repository.join("Cargo.toml"),
"[package]\nname = \"john-slop\"\nversion = \"0.1.27-rc.6\"\n",
)
.expect("manifest should be written");
fs::write(repository.join("token.txt"), "test-token\n")
.expect("token file should be written");
let fake_release = fake_bin.join("rust_realease");
fs::write(
&fake_release,
"#!/bin/sh\n\
[ \"$GITEA_TOKEN\" = test-token ] || exit 91\n\
git -C \"$1\" remote get-url origin >\"$OBSERVED_ORIGIN\"\n\
cat \"$1/rust-release.toml\" >\"$OBSERVED_CONFIG\"\n\
printf '%s\\n' \"$@\" >\"$OBSERVED_ARGS\"\n\
exit \"$FAKE_RELEASE_STATUS\"\n",
)
.expect("fake release executable should be written");
let mut permissions = fs::metadata(&fake_release)
.expect("fake release metadata should be readable")
.permissions();
permissions.set_mode(0o755);
fs::set_permissions(&fake_release, permissions)
.expect("fake release executable permissions should be set");
assert!(git(&repository, &["init", "--quiet"]).status.success());
assert!(
git(
&repository,
&["remote", "add", "origin", DEVELOPMENT_ORIGIN]
)
.status
.success()
);
let observed_origin = temporary.path().join("observed-origin.txt");
let observed_config = temporary.path().join("observed-config.toml");
let observed_args = temporary.path().join("observed-args.txt");
let path = format!(
"{}:{}",
fake_bin.display(),
env::var("PATH").expect("PATH should be available")
);
let output = run(Command::new(repository.join("release.sh"))
.arg(repository.join("token.txt"))
.arg("--dry-run")
.env("PATH", path)
.env("OBSERVED_ORIGIN", &observed_origin)
.env("OBSERVED_CONFIG", &observed_config)
.env("OBSERVED_ARGS", &observed_args)
.env("FAKE_RELEASE_STATUS", release_status.to_string()));
assert_eq!(output.status.code(), Some(release_status));
assert_eq!(
fs::read_to_string(&observed_origin)
.expect("fake release should record the temporary origin")
.trim(),
DEVELOPMENT_ORIGIN
);
assert_eq!(
fs::read_to_string(&observed_config)
.expect("fake release should record the project configuration"),
RELEASE_CONFIG
);
assert_eq!(
String::from_utf8(git(&repository, &["remote", "get-url", "origin"]).stdout)
.expect("origin should be UTF-8")
.trim(),
DEVELOPMENT_ORIGIN
);
let arguments = fs::read_to_string(&observed_args)
.expect("fake release should record publisher arguments");
assert!(arguments.lines().any(|argument| argument == "both"));
assert!(arguments.lines().any(|argument| argument == "--prerelease"));
}
}