280 lines
9.3 KiB
Rust
280 lines
9.3 KiB
Rust
#![cfg(unix)]
|
|
|
|
use std::{
|
|
env, fs,
|
|
os::unix::fs::PermissionsExt,
|
|
path::{Path, PathBuf},
|
|
process::{Command, Output},
|
|
sync::atomic::{AtomicUsize, Ordering},
|
|
};
|
|
|
|
const DEVELOPMENT_ORIGIN: &str = "git@git.dandaedre.com:Archive/rping.git";
|
|
const RELEASE_CONFIG: &str = "[[repository.fallbacks]]\n\
|
|
origin = \"git@git.dandaedre.com:Archive/rping.git\"\n\
|
|
fallback-url = \"https://proxy.dandaedre.com/gitea/Archive/rping\"\n";
|
|
static NEXT_TEMPORARY: AtomicUsize = AtomicUsize::new(0);
|
|
|
|
struct TemporaryDirectory(PathBuf);
|
|
|
|
impl TemporaryDirectory {
|
|
fn new(label: &str) -> Self {
|
|
let serial = NEXT_TEMPORARY.fetch_add(1, Ordering::Relaxed);
|
|
let path = env::temp_dir().join(format!("rping-{label}-{}-{serial}", std::process::id()));
|
|
fs::create_dir(&path).expect("temporary directory should be created");
|
|
Self(path)
|
|
}
|
|
|
|
fn path(&self) -> &Path {
|
|
&self.0
|
|
}
|
|
}
|
|
|
|
impl Drop for TemporaryDirectory {
|
|
fn drop(&mut self) {
|
|
let _ = fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
|
|
fn run(command: &mut Command) -> Output {
|
|
command.output().expect("test command should start")
|
|
}
|
|
|
|
fn make_executable(path: &Path) {
|
|
let mut permissions = fs::metadata(path)
|
|
.expect("executable metadata should be readable")
|
|
.permissions();
|
|
permissions.set_mode(0o755);
|
|
fs::set_permissions(path, permissions).expect("executable mode should be set");
|
|
}
|
|
|
|
fn prepare_repository(temporary: &TemporaryDirectory, version_line: &str) -> (PathBuf, PathBuf) {
|
|
let repository = temporary.path().join("repository with spaces");
|
|
let fake_bin = temporary.path().join("fake bin");
|
|
fs::create_dir(&repository).expect("repository should be created");
|
|
fs::create_dir(&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");
|
|
make_executable(&repository.join("release.sh"));
|
|
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"),
|
|
format!("[package]\nname = \"rping\"\n{version_line}\n"),
|
|
)
|
|
.expect("manifest should be written");
|
|
|
|
assert!(run(Command::new("git")
|
|
.arg("-C")
|
|
.arg(&repository)
|
|
.args(["init", "--quiet"]))
|
|
.status
|
|
.success());
|
|
assert!(run(Command::new("git").arg("-C").arg(&repository).args([
|
|
"remote",
|
|
"add",
|
|
"origin",
|
|
DEVELOPMENT_ORIGIN
|
|
]))
|
|
.status
|
|
.success());
|
|
|
|
(repository, fake_bin)
|
|
}
|
|
|
|
fn install_fake_publisher(fake_bin: &Path) {
|
|
let publisher = fake_bin.join("rust_realease");
|
|
fs::write(
|
|
&publisher,
|
|
"#!/bin/sh\n\
|
|
[ \"$GITEA_TOKEN\" = test-token ] || exit 91\n\
|
|
printf '%s\\n' \"$GITEA_TOKEN\" >\"$OBSERVED_TOKEN\"\n\
|
|
printf '%s\\n' \"$@\" >\"$OBSERVED_ARGS\"\n\
|
|
git -C \"$1\" remote get-url origin >\"$OBSERVED_ORIGIN\"\n\
|
|
cat \"$1/rust-release.toml\" >\"$OBSERVED_CONFIG\"\n\
|
|
printf 'fake publisher ran\\n'\n\
|
|
exit \"$FAKE_RELEASE_STATUS\"\n",
|
|
)
|
|
.expect("fake publisher should be written");
|
|
make_executable(&publisher);
|
|
}
|
|
|
|
fn wrapper_command(
|
|
repository: &Path,
|
|
fake_bin: &Path,
|
|
token_file: &Path,
|
|
temporary: &TemporaryDirectory,
|
|
status: i32,
|
|
) -> Command {
|
|
let mut command = Command::new(repository.join("release.sh"));
|
|
command
|
|
.arg(token_file)
|
|
.env(
|
|
"PATH",
|
|
format!(
|
|
"{}:{}",
|
|
fake_bin.display(),
|
|
env::var("PATH").expect("PATH should be available")
|
|
),
|
|
)
|
|
.env("FAKE_RELEASE_STATUS", status.to_string())
|
|
.env("OBSERVED_TOKEN", temporary.path().join("observed token"))
|
|
.env("OBSERVED_ARGS", temporary.path().join("observed args"))
|
|
.env("OBSERVED_ORIGIN", temporary.path().join("observed origin"))
|
|
.env("OBSERVED_CONFIG", temporary.path().join("observed config"));
|
|
command
|
|
}
|
|
|
|
#[test]
|
|
fn stable_release_forwards_exact_arguments_without_leaking_token() {
|
|
let temporary = TemporaryDirectory::new("stable-release");
|
|
let (repository, fake_bin) = prepare_repository(&temporary, "version = \"0.1.0\"");
|
|
install_fake_publisher(&fake_bin);
|
|
let token_file = temporary.path().join("token file");
|
|
fs::write(&token_file, "test-token\nignored-second-line\n").expect("token should be written");
|
|
|
|
let output = run(
|
|
wrapper_command(&repository, &fake_bin, &token_file, &temporary, 0).args([
|
|
"--dry-run",
|
|
"--tag",
|
|
"tag with spaces",
|
|
]),
|
|
);
|
|
assert!(output.status.success());
|
|
assert!(!String::from_utf8_lossy(&output.stdout).contains("test-token"));
|
|
assert!(!String::from_utf8_lossy(&output.stderr).contains("test-token"));
|
|
|
|
let arguments = fs::read_to_string(temporary.path().join("observed args"))
|
|
.expect("arguments should be recorded");
|
|
assert_eq!(
|
|
arguments.lines().collect::<Vec<_>>(),
|
|
[
|
|
repository
|
|
.to_str()
|
|
.expect("repository path should be UTF-8"),
|
|
"--package",
|
|
"rping",
|
|
"--artifact-format",
|
|
"both",
|
|
"--dry-run",
|
|
"--tag",
|
|
"tag with spaces",
|
|
]
|
|
);
|
|
assert!(!arguments.contains("test-token"));
|
|
assert_eq!(
|
|
fs::read_to_string(temporary.path().join("observed token"))
|
|
.expect("token should be recorded"),
|
|
"test-token\n"
|
|
);
|
|
assert_eq!(
|
|
fs::read_to_string(temporary.path().join("observed config"))
|
|
.expect("config should be recorded"),
|
|
RELEASE_CONFIG
|
|
);
|
|
assert_eq!(
|
|
fs::read_to_string(temporary.path().join("observed origin"))
|
|
.expect("origin should be recorded")
|
|
.trim(),
|
|
DEVELOPMENT_ORIGIN
|
|
);
|
|
assert_eq!(
|
|
String::from_utf8(
|
|
run(Command::new("git")
|
|
.arg("-C")
|
|
.arg(&repository)
|
|
.args(["remote", "get-url", "origin"]))
|
|
.stdout
|
|
)
|
|
.expect("origin should be UTF-8")
|
|
.trim(),
|
|
DEVELOPMENT_ORIGIN
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn prerelease_is_added_and_publisher_status_is_preserved() {
|
|
let temporary = TemporaryDirectory::new("prerelease");
|
|
let (repository, fake_bin) = prepare_repository(&temporary, "version = \"0.2.0-rc.1\"");
|
|
install_fake_publisher(&fake_bin);
|
|
let token_file = temporary.path().join("token");
|
|
fs::write(&token_file, "test-token\n").expect("token should be written");
|
|
|
|
let output = run(&mut wrapper_command(
|
|
&repository,
|
|
&fake_bin,
|
|
&token_file,
|
|
&temporary,
|
|
17,
|
|
));
|
|
assert_eq!(output.status.code(), Some(17));
|
|
let arguments = fs::read_to_string(temporary.path().join("observed args"))
|
|
.expect("arguments should be recorded");
|
|
assert!(arguments.lines().any(|argument| argument == "--prerelease"));
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_inputs_fail_before_publishing() {
|
|
let temporary = TemporaryDirectory::new("invalid-inputs");
|
|
let (repository, fake_bin) = prepare_repository(&temporary, "version = \"0.1.0\"");
|
|
install_fake_publisher(&fake_bin);
|
|
let wrapper = repository.join("release.sh");
|
|
let empty_path = temporary.path().join("empty path");
|
|
fs::create_dir(&empty_path).expect("empty PATH directory should be created");
|
|
|
|
assert!(!run(&mut Command::new(&wrapper)).status.success());
|
|
assert!(
|
|
!run(Command::new(&wrapper).arg(temporary.path().join("missing token")))
|
|
.status
|
|
.success()
|
|
);
|
|
|
|
let empty_token = temporary.path().join("empty token");
|
|
fs::write(&empty_token, "").expect("empty token should be written");
|
|
assert!(!run(Command::new(&wrapper).arg(&empty_token))
|
|
.status
|
|
.success());
|
|
|
|
let unreadable_token = temporary.path().join("unreadable token");
|
|
fs::write(&unreadable_token, "test-token\n").expect("token should be written");
|
|
let mut permissions = fs::metadata(&unreadable_token)
|
|
.expect("token metadata should be readable")
|
|
.permissions();
|
|
permissions.set_mode(0o000);
|
|
fs::set_permissions(&unreadable_token, permissions).expect("token mode should be set");
|
|
assert!(!run(Command::new(&wrapper).arg(&unreadable_token))
|
|
.status
|
|
.success());
|
|
|
|
let valid_token = temporary.path().join("valid token");
|
|
fs::write(&valid_token, "test-token\n").expect("token should be written");
|
|
let missing_publisher = run(Command::new(&wrapper)
|
|
.arg(&valid_token)
|
|
.env("PATH", &empty_path));
|
|
assert_eq!(missing_publisher.status.code(), Some(2));
|
|
assert!(String::from_utf8_lossy(&missing_publisher.stderr)
|
|
.contains("rust_realease is not installed"));
|
|
|
|
fs::write(
|
|
repository.join("Cargo.toml"),
|
|
"[package]\nname = \"rping\"\n",
|
|
)
|
|
.expect("manifest without a version should be written");
|
|
let unresolved_version = run(&mut wrapper_command(
|
|
&repository,
|
|
&fake_bin,
|
|
&valid_token,
|
|
&temporary,
|
|
0,
|
|
));
|
|
assert_eq!(unresolved_version.status.code(), Some(2));
|
|
assert!(String::from_utf8_lossy(&unresolved_version.stderr)
|
|
.contains("could not determine the selected package version"));
|
|
}
|