BlueGit

timfa posprint

test: run bash release-script tests on Unix only

Windows SaaS runners have no bash; keep filename and CI string
assertions cross-platform so test:windows can pass.

Co-authored-by: tim <tim@timfalken.com>

timfa project_84475926_bot_764f118ece54db37209130d2bbcb4ae7 · pushed by timfa

Authored 2026-09-19 · 8 weeks ago

Hash
4b2342a4ff573e365a9b9543f6266bd687e1c703
Parent
4120bce1
1 file changed +184 −178
tests/release_scripts.rs +184 −178
@@ -1,200 +1,206 @@
1 1 //! Regression tests for tag-release packaging scripts and CI asset names.
2 //!
3 //! Shell-script integration tests run on Unix only. Windows SaaS runners do not
4 //! have bash; the Linux release path is unchanged and still covered by `test:linux`.
2 5
3 use std::fs;
4 use std::path::Path;
5 use std::process::Command;
6 #[cfg(unix)]
7 mod unix_scripts {
8 use std::fs;
9 use std::path::Path;
10 use std::process::Command;
6 11
7 fn repo_root() -> std::path::PathBuf {
8 Path::new(env!("CARGO_MANIFEST_DIR")).to_path_buf()
9 }
12 fn repo_root() -> std::path::PathBuf {
13 Path::new(env!("CARGO_MANIFEST_DIR")).to_path_buf()
14 }
10 15
11 fn write_fake_usr_tree(dir: &Path, marker: &str) {
12 let bin = dir.join("usr/bin");
13 fs::create_dir_all(&bin).unwrap();
14 fs::write(bin.join("posprint"), marker).unwrap();
15 }
16 fn write_fake_usr_tree(dir: &Path, marker: &str) {
17 let bin = dir.join("usr/bin");
18 fs::create_dir_all(&bin).unwrap();
19 fs::write(bin.join("posprint"), marker).unwrap();
20 }
16 21
17 fn tar_usr(src_root: &Path, dest_pkg: &Path) {
18 let status = Command::new("tar")
19 .args(["-C", src_root.to_str().unwrap(), "-cf"])
20 .arg(dest_pkg)
21 .arg("usr")
22 .status()
23 .expect("spawn tar");
24 assert!(status.success(), "tar failed creating {}", dest_pkg.display());
25 }
22 fn tar_usr(src_root: &Path, dest_pkg: &Path) {
23 let status = Command::new("tar")
24 .args(["-C", src_root.to_str().unwrap(), "-cf"])
25 .arg(dest_pkg)
26 .arg("usr")
27 .status()
28 .expect("spawn tar");
29 assert!(status.success(), "tar failed creating {}", dest_pkg.display());
30 }
26 31
27 fn run_tarball_script(args: &[&str]) -> std::process::Output {
28 let script = repo_root().join("scripts/make-linux-bin-tarball.sh");
29 Command::new("bash")
30 .arg(&script)
31 .args(args)
32 .output()
33 .unwrap_or_else(|e| panic!("run make-linux-bin-tarball.sh: {e}"))
34 }
32 fn run_tarball_script(args: &[&str]) -> std::process::Output {
33 let script = repo_root().join("scripts/make-linux-bin-tarball.sh");
34 Command::new("bash")
35 .arg(&script)
36 .args(args)
37 .output()
38 .unwrap_or_else(|e| panic!("run make-linux-bin-tarball.sh: {e}"))
39 }
35 40
36 fn run_publish_release(args: &[&str]) -> std::process::Output {
37 let script = repo_root().join("scripts/publish-gitlab-release.sh");
38 Command::new("bash")
39 .arg(&script)
40 .args(args)
41 .output()
42 .unwrap_or_else(|e| panic!("run publish-gitlab-release.sh: {e}"))
43 }
41 fn run_publish_release(args: &[&str]) -> std::process::Output {
42 let script = repo_root().join("scripts/publish-gitlab-release.sh");
43 Command::new("bash")
44 .arg(&script)
45 .args(args)
46 .output()
47 .unwrap_or_else(|e| panic!("run publish-gitlab-release.sh: {e}"))
48 }
44 49
45 #[test]
46 fn tarball_script_ignores_debug_package_when_glob_expands_to_two() {
47 let tmp = tempfile::tempdir().unwrap();
48 let main_root = tmp.path().join("main");
49 let debug_root = tmp.path().join("debug");
50 write_fake_usr_tree(&main_root, "main-bin");
51 write_fake_usr_tree(&debug_root, "debug-bin");
50 #[test]
51 fn tarball_script_ignores_debug_package_when_glob_expands_to_two() {
52 let tmp = tempfile::tempdir().unwrap();
53 let main_root = tmp.path().join("main");
54 let debug_root = tmp.path().join("debug");
55 write_fake_usr_tree(&main_root, "main-bin");
56 write_fake_usr_tree(&debug_root, "debug-bin");
52 57
53 let main_pkg = tmp.path().join("posprint-0.5.7-1-x86_64.pkg.tar");
54 let debug_pkg = tmp.path().join("posprint-debug-0.5.7-1-x86_64.pkg.tar");
55 tar_usr(&main_root, &main_pkg);
56 tar_usr(&debug_root, &debug_pkg);
57 let debug_before = fs::read(&debug_pkg).unwrap();
58 let main_pkg = tmp.path().join("posprint-0.5.7-1-x86_64.pkg.tar");
59 let debug_pkg = tmp.path().join("posprint-debug-0.5.7-1-x86_64.pkg.tar");
60 tar_usr(&main_root, &main_pkg);
61 tar_usr(&debug_root, &debug_pkg);
62 let debug_before = fs::read(&debug_pkg).unwrap();
58 63
59 let out = tmp.path().join("posprint-0.5.7-x86_64.tar.gz");
60 let output = run_tarball_script(&[
61 main_pkg.to_str().unwrap(),
62 debug_pkg.to_str().unwrap(),
63 out.to_str().unwrap(),
64 "0.5.7",
65 ]);
66 assert!(
67 output.status.success(),
68 "stdout:\n{}\nstderr:\n{}",
69 String::from_utf8_lossy(&output.stdout),
70 String::from_utf8_lossy(&output.stderr)
71 );
72 assert!(out.is_file(), "tarball was not written to the intended out path");
73 assert_ne!(out.metadata().unwrap().len(), 0);
74 assert_eq!(
75 fs::read(&debug_pkg).unwrap(),
76 debug_before,
77 "debug package must not be overwritten when it is $2"
78 );
64 let out = tmp.path().join("posprint-0.5.7-x86_64.tar.gz");
65 let output = run_tarball_script(&[
66 main_pkg.to_str().unwrap(),
67 debug_pkg.to_str().unwrap(),
68 out.to_str().unwrap(),
69 "0.5.7",
70 ]);
71 assert!(
72 output.status.success(),
73 "stdout:\n{}\nstderr:\n{}",
74 String::from_utf8_lossy(&output.stdout),
75 String::from_utf8_lossy(&output.stderr)
76 );
77 assert!(out.is_file(), "tarball was not written to the intended out path");
78 assert_ne!(out.metadata().unwrap().len(), 0);
79 assert_eq!(
80 fs::read(&debug_pkg).unwrap(),
81 debug_before,
82 "debug package must not be overwritten when it is $2"
83 );
79 84
80 let extract = tmp.path().join("extract");
81 fs::create_dir_all(&extract).unwrap();
82 let status = Command::new("tar")
83 .args(["-C", extract.to_str().unwrap(), "-xzf"])
84 .arg(&out)
85 .status()
86 .unwrap();
87 assert!(status.success());
88 let packed = fs::read_to_string(extract.join("usr/bin/posprint")).unwrap();
89 assert_eq!(packed, "main-bin");
90 }
85 let extract = tmp.path().join("extract");
86 fs::create_dir_all(&extract).unwrap();
87 let status = Command::new("tar")
88 .args(["-C", extract.to_str().unwrap(), "-xzf"])
89 .arg(&out)
90 .status()
91 .unwrap();
92 assert!(status.success());
93 let packed = fs::read_to_string(extract.join("usr/bin/posprint")).unwrap();
94 assert_eq!(packed, "main-bin");
95 }
91 96
92 #[test]
93 fn tarball_script_rejects_only_debug_packages() {
94 let tmp = tempfile::tempdir().unwrap();
95 let debug_root = tmp.path().join("debug");
96 write_fake_usr_tree(&debug_root, "debug-bin");
97 let debug_pkg = tmp.path().join("posprint-debug-0.5.7-1-x86_64.pkg.tar");
98 tar_usr(&debug_root, &debug_pkg);
99 let out = tmp.path().join("posprint-0.5.7-x86_64.tar.gz");
97 #[test]
98 fn tarball_script_rejects_only_debug_packages() {
99 let tmp = tempfile::tempdir().unwrap();
100 let debug_root = tmp.path().join("debug");
101 write_fake_usr_tree(&debug_root, "debug-bin");
102 let debug_pkg = tmp.path().join("posprint-debug-0.5.7-1-x86_64.pkg.tar");
103 tar_usr(&debug_root, &debug_pkg);
104 let out = tmp.path().join("posprint-0.5.7-x86_64.tar.gz");
100 105
101 let output = run_tarball_script(&[
102 debug_pkg.to_str().unwrap(),
103 out.to_str().unwrap(),
104 "0.5.7",
105 ]);
106 assert!(!output.status.success());
107 let stderr = String::from_utf8_lossy(&output.stderr);
108 assert!(
109 stderr.contains("No non-debug"),
110 "unexpected stderr: {stderr}"
111 );
112 assert!(!out.exists());
113 }
106 let output = run_tarball_script(&[
107 debug_pkg.to_str().unwrap(),
108 out.to_str().unwrap(),
109 "0.5.7",
110 ]);
111 assert!(!output.status.success());
112 let stderr = String::from_utf8_lossy(&output.stderr);
113 assert!(
114 stderr.contains("No non-debug"),
115 "unexpected stderr: {stderr}"
116 );
117 assert!(!out.exists());
118 }
114 119
115 #[test]
116 fn tarball_script_classic_three_args_still_works() {
117 let tmp = tempfile::tempdir().unwrap();
118 let main_root = tmp.path().join("main");
119 write_fake_usr_tree(&main_root, "only-main");
120 let main_pkg = tmp.path().join("posprint-0.5.7-1-x86_64.pkg.tar");
121 tar_usr(&main_root, &main_pkg);
122 let out = tmp.path().join("out.tar.gz");
120 #[test]
121 fn tarball_script_classic_three_args_still_works() {
122 let tmp = tempfile::tempdir().unwrap();
123 let main_root = tmp.path().join("main");
124 write_fake_usr_tree(&main_root, "only-main");
125 let main_pkg = tmp.path().join("posprint-0.5.7-1-x86_64.pkg.tar");
126 tar_usr(&main_root, &main_pkg);
127 let out = tmp.path().join("out.tar.gz");
123 128
124 let output = run_tarball_script(&[main_pkg.to_str().unwrap(), out.to_str().unwrap(), "0.5.7"]);
125 assert!(
126 output.status.success(),
127 "stderr: {}",
128 String::from_utf8_lossy(&output.stderr)
129 );
130 assert!(out.is_file());
131 }
129 let output = run_tarball_script(&[main_pkg.to_str().unwrap(), out.to_str().unwrap(), "0.5.7"]);
130 assert!(
131 output.status.success(),
132 "stderr: {}",
133 String::from_utf8_lossy(&output.stderr)
134 );
135 assert!(out.is_file());
136 }
132 137
133 #[test]
134 fn publish_release_dry_run_uses_real_filenames() {
135 let tmp = tempfile::tempdir().unwrap();
136 let dist = tmp.path();
137 fs::write(dist.join("posprint_0.5.7-1_amd64.deb"), b"deb").unwrap();
138 fs::write(
139 dist.join("posprint-0.5.7-1-x86_64.pkg.tar.zst"),
140 b"pkg",
141 )
142 .unwrap();
143 fs::write(dist.join("posprint-debug-0.5.7-1-x86_64.pkg.tar.zst"), b"dbg").unwrap();
144 fs::write(dist.join("posprint-0.5.7-x86_64.tar.gz"), b"tgz").unwrap();
145 fs::write(dist.join("posprint.exe"), b"exe").unwrap();
138 #[test]
139 fn publish_release_dry_run_uses_real_filenames() {
140 let tmp = tempfile::tempdir().unwrap();
141 let dist = tmp.path();
142 fs::write(dist.join("posprint_0.5.7-1_amd64.deb"), b"deb").unwrap();
143 fs::write(
144 dist.join("posprint-0.5.7-1-x86_64.pkg.tar.zst"),
145 b"pkg",
146 )
147 .unwrap();
148 fs::write(dist.join("posprint-debug-0.5.7-1-x86_64.pkg.tar.zst"), b"dbg").unwrap();
149 fs::write(dist.join("posprint-0.5.7-x86_64.tar.gz"), b"tgz").unwrap();
150 fs::write(dist.join("posprint.exe"), b"exe").unwrap();
146 151
147 let output = run_publish_release(&[
148 "--dry-run",
149 "--dist",
150 dist.to_str().unwrap(),
151 "0.5.7",
152 ]);
153 assert!(
154 output.status.success(),
155 "stdout:\n{}\nstderr:\n{}",
156 String::from_utf8_lossy(&output.stdout),
157 String::from_utf8_lossy(&output.stderr)
158 );
159 let stdout = String::from_utf8_lossy(&output.stdout);
160 assert!(stdout.contains("posprint_0.5.7-1_amd64.deb"));
161 assert!(stdout.contains("posprint-0.5.7-1-x86_64.pkg.tar.zst"));
162 assert!(
163 !stdout.contains("posprint-debug-"),
164 "debug package must not be a release asset:\n{stdout}"
165 );
166 assert!(
167 !stdout.contains("posprint_0.5.7-1-x86_64"),
168 "Arch package must use hyphens, not posprint_ver:\n{stdout}"
169 );
170 assert!(stdout.contains("posprint-0.5.7-x86_64.tar.gz"));
171 assert!(stdout.contains("posprint.exe"));
172 }
152 let output = run_publish_release(&[
153 "--dry-run",
154 "--dist",
155 dist.to_str().unwrap(),
156 "0.5.7",
157 ]);
158 assert!(
159 output.status.success(),
160 "stdout:\n{}\nstderr:\n{}",
161 String::from_utf8_lossy(&output.stdout),
162 String::from_utf8_lossy(&output.stderr)
163 );
164 let stdout = String::from_utf8_lossy(&output.stdout);
165 assert!(stdout.contains("posprint_0.5.7-1_amd64.deb"));
166 assert!(stdout.contains("posprint-0.5.7-1-x86_64.pkg.tar.zst"));
167 assert!(
168 !stdout.contains("posprint-debug-"),
169 "debug package must not be a release asset:\n{stdout}"
170 );
171 assert!(
172 !stdout.contains("posprint_0.5.7-1-x86_64"),
173 "Arch package must use hyphens, not posprint_ver:\n{stdout}"
174 );
175 assert!(stdout.contains("posprint-0.5.7-x86_64.tar.gz"));
176 assert!(stdout.contains("posprint.exe"));
177 }
173 178
174 #[test]
175 fn publish_release_dry_run_rejects_missing_tarball() {
176 let tmp = tempfile::tempdir().unwrap();
177 let dist = tmp.path();
178 fs::write(dist.join("posprint_0.5.7-1_amd64.deb"), b"deb").unwrap();
179 fs::write(
180 dist.join("posprint-0.5.7-1-x86_64.pkg.tar.zst"),
181 b"pkg",
182 )
183 .unwrap();
184 fs::write(dist.join("posprint.exe"), b"exe").unwrap();
179 #[test]
180 fn publish_release_dry_run_rejects_missing_tarball() {
181 let tmp = tempfile::tempdir().unwrap();
182 let dist = tmp.path();
183 fs::write(dist.join("posprint_0.5.7-1_amd64.deb"), b"deb").unwrap();
184 fs::write(
185 dist.join("posprint-0.5.7-1-x86_64.pkg.tar.zst"),
186 b"pkg",
187 )
188 .unwrap();
189 fs::write(dist.join("posprint.exe"), b"exe").unwrap();
185 190
186 let output = run_publish_release(&[
187 "--dry-run",
188 "--dist",
189 dist.to_str().unwrap(),
190 "0.5.7",
191 ]);
192 assert!(!output.status.success());
193 let stderr = String::from_utf8_lossy(&output.stderr);
194 assert!(
195 stderr.contains("tar.gz"),
196 "expected missing-tarball error, got: {stderr}"
197 );
191 let output = run_publish_release(&[
192 "--dry-run",
193 "--dist",
194 dist.to_str().unwrap(),
195 "0.5.7",
196 ]);
197 assert!(!output.status.success());
198 let stderr = String::from_utf8_lossy(&output.stderr);
199 assert!(
200 stderr.contains("tar.gz"),
201 "expected missing-tarball error, got: {stderr}"
202 );
203 }
198 204 }
199 205
200 206 #[test]
@@ -1,200 +1,206 @@
1//! Regression tests for tag-release packaging scripts and CI asset names.
1//! Regression tests for tag-release packaging scripts and CI asset names.
2//!
3//! Shell-script integration tests run on Unix only. Windows SaaS runners do not
4//! have bash; the Linux release path is unchanged and still covered by `test:linux`.
2
5
3use std::fs;
6#[cfg(unix)]
4use std::path::Path;
7mod unix_scripts {
5use std::process::Command;
8 use std::fs;
9 use std::path::Path;
10 use std::process::Command;
6
11
7fn repo_root() -> std::path::PathBuf {
12 fn repo_root() -> std::path::PathBuf {
8 Path::new(env!("CARGO_MANIFEST_DIR")).to_path_buf()
13 Path::new(env!("CARGO_MANIFEST_DIR")).to_path_buf()
9}
14 }
10
15
11fn write_fake_usr_tree(dir: &Path, marker: &str) {
16 fn write_fake_usr_tree(dir: &Path, marker: &str) {
12 let bin = dir.join("usr/bin");
17 let bin = dir.join("usr/bin");
13 fs::create_dir_all(&bin).unwrap();
18 fs::create_dir_all(&bin).unwrap();
14 fs::write(bin.join("posprint"), marker).unwrap();
19 fs::write(bin.join("posprint"), marker).unwrap();
15}
20 }
16
21
17fn tar_usr(src_root: &Path, dest_pkg: &Path) {
22 fn tar_usr(src_root: &Path, dest_pkg: &Path) {
18 let status = Command::new("tar")
23 let status = Command::new("tar")
19 .args(["-C", src_root.to_str().unwrap(), "-cf"])
24 .args(["-C", src_root.to_str().unwrap(), "-cf"])
20 .arg(dest_pkg)
25 .arg(dest_pkg)
21 .arg("usr")
26 .arg("usr")
22 .status()
27 .status()
23 .expect("spawn tar");
28 .expect("spawn tar");
24 assert!(status.success(), "tar failed creating {}", dest_pkg.display());
29 assert!(status.success(), "tar failed creating {}", dest_pkg.display());
25}
30 }
26
31
27fn run_tarball_script(args: &[&str]) -> std::process::Output {
32 fn run_tarball_script(args: &[&str]) -> std::process::Output {
28 let script = repo_root().join("scripts/make-linux-bin-tarball.sh");
33 let script = repo_root().join("scripts/make-linux-bin-tarball.sh");
29 Command::new("bash")
34 Command::new("bash")
30 .arg(&script)
35 .arg(&script)
31 .args(args)
36 .args(args)
32 .output()
37 .output()
33 .unwrap_or_else(|e| panic!("run make-linux-bin-tarball.sh: {e}"))
38 .unwrap_or_else(|e| panic!("run make-linux-bin-tarball.sh: {e}"))
34}
39 }
35
40
36fn run_publish_release(args: &[&str]) -> std::process::Output {
41 fn run_publish_release(args: &[&str]) -> std::process::Output {
37 let script = repo_root().join("scripts/publish-gitlab-release.sh");
42 let script = repo_root().join("scripts/publish-gitlab-release.sh");
38 Command::new("bash")
43 Command::new("bash")
39 .arg(&script)
44 .arg(&script)
40 .args(args)
45 .args(args)
41 .output()
46 .output()
42 .unwrap_or_else(|e| panic!("run publish-gitlab-release.sh: {e}"))
47 .unwrap_or_else(|e| panic!("run publish-gitlab-release.sh: {e}"))
43}
48 }
44
49
45#[test]
50 #[test]
46fn tarball_script_ignores_debug_package_when_glob_expands_to_two() {
51 fn tarball_script_ignores_debug_package_when_glob_expands_to_two() {
47 let tmp = tempfile::tempdir().unwrap();
52 let tmp = tempfile::tempdir().unwrap();
48 let main_root = tmp.path().join("main");
53 let main_root = tmp.path().join("main");
49 let debug_root = tmp.path().join("debug");
54 let debug_root = tmp.path().join("debug");
50 write_fake_usr_tree(&main_root, "main-bin");
55 write_fake_usr_tree(&main_root, "main-bin");
51 write_fake_usr_tree(&debug_root, "debug-bin");
56 write_fake_usr_tree(&debug_root, "debug-bin");
52
57
53 let main_pkg = tmp.path().join("posprint-0.5.7-1-x86_64.pkg.tar");
58 let main_pkg = tmp.path().join("posprint-0.5.7-1-x86_64.pkg.tar");
54 let debug_pkg = tmp.path().join("posprint-debug-0.5.7-1-x86_64.pkg.tar");
59 let debug_pkg = tmp.path().join("posprint-debug-0.5.7-1-x86_64.pkg.tar");
55 tar_usr(&main_root, &main_pkg);
60 tar_usr(&main_root, &main_pkg);
56 tar_usr(&debug_root, &debug_pkg);
61 tar_usr(&debug_root, &debug_pkg);
57 let debug_before = fs::read(&debug_pkg).unwrap();
62 let debug_before = fs::read(&debug_pkg).unwrap();
58
63
59 let out = tmp.path().join("posprint-0.5.7-x86_64.tar.gz");
64 let out = tmp.path().join("posprint-0.5.7-x86_64.tar.gz");
60 let output = run_tarball_script(&[
65 let output = run_tarball_script(&[
61 main_pkg.to_str().unwrap(),
66 main_pkg.to_str().unwrap(),
62 debug_pkg.to_str().unwrap(),
67 debug_pkg.to_str().unwrap(),
63 out.to_str().unwrap(),
68 out.to_str().unwrap(),
64 "0.5.7",
69 "0.5.7",
65 ]);
70 ]);
66 assert!(
71 assert!(
67 output.status.success(),
72 output.status.success(),
68 "stdout:\n{}\nstderr:\n{}",
73 "stdout:\n{}\nstderr:\n{}",
69 String::from_utf8_lossy(&output.stdout),
74 String::from_utf8_lossy(&output.stdout),
70 String::from_utf8_lossy(&output.stderr)
75 String::from_utf8_lossy(&output.stderr)
71 );
76 );
72 assert!(out.is_file(), "tarball was not written to the intended out path");
77 assert!(out.is_file(), "tarball was not written to the intended out path");
73 assert_ne!(out.metadata().unwrap().len(), 0);
78 assert_ne!(out.metadata().unwrap().len(), 0);
74 assert_eq!(
79 assert_eq!(
75 fs::read(&debug_pkg).unwrap(),
80 fs::read(&debug_pkg).unwrap(),
76 debug_before,
81 debug_before,
77 "debug package must not be overwritten when it is $2"
82 "debug package must not be overwritten when it is $2"
78 );
83 );
79
84
80 let extract = tmp.path().join("extract");
85 let extract = tmp.path().join("extract");
81 fs::create_dir_all(&extract).unwrap();
86 fs::create_dir_all(&extract).unwrap();
82 let status = Command::new("tar")
87 let status = Command::new("tar")
83 .args(["-C", extract.to_str().unwrap(), "-xzf"])
88 .args(["-C", extract.to_str().unwrap(), "-xzf"])
84 .arg(&out)
89 .arg(&out)
85 .status()
90 .status()
86 .unwrap();
91 .unwrap();
87 assert!(status.success());
92 assert!(status.success());
88 let packed = fs::read_to_string(extract.join("usr/bin/posprint")).unwrap();
93 let packed = fs::read_to_string(extract.join("usr/bin/posprint")).unwrap();
89 assert_eq!(packed, "main-bin");
94 assert_eq!(packed, "main-bin");
90}
95 }
91
96
92#[test]
97 #[test]
93fn tarball_script_rejects_only_debug_packages() {
98 fn tarball_script_rejects_only_debug_packages() {
94 let tmp = tempfile::tempdir().unwrap();
99 let tmp = tempfile::tempdir().unwrap();
95 let debug_root = tmp.path().join("debug");
100 let debug_root = tmp.path().join("debug");
96 write_fake_usr_tree(&debug_root, "debug-bin");
101 write_fake_usr_tree(&debug_root, "debug-bin");
97 let debug_pkg = tmp.path().join("posprint-debug-0.5.7-1-x86_64.pkg.tar");
102 let debug_pkg = tmp.path().join("posprint-debug-0.5.7-1-x86_64.pkg.tar");
98 tar_usr(&debug_root, &debug_pkg);
103 tar_usr(&debug_root, &debug_pkg);
99 let out = tmp.path().join("posprint-0.5.7-x86_64.tar.gz");
104 let out = tmp.path().join("posprint-0.5.7-x86_64.tar.gz");
100
105
101 let output = run_tarball_script(&[
106 let output = run_tarball_script(&[
102 debug_pkg.to_str().unwrap(),
107 debug_pkg.to_str().unwrap(),
103 out.to_str().unwrap(),
108 out.to_str().unwrap(),
104 "0.5.7",
109 "0.5.7",
105 ]);
110 ]);
106 assert!(!output.status.success());
111 assert!(!output.status.success());
107 let stderr = String::from_utf8_lossy(&output.stderr);
112 let stderr = String::from_utf8_lossy(&output.stderr);
108 assert!(
113 assert!(
109 stderr.contains("No non-debug"),
114 stderr.contains("No non-debug"),
110 "unexpected stderr: {stderr}"
115 "unexpected stderr: {stderr}"
111 );
116 );
112 assert!(!out.exists());
117 assert!(!out.exists());
113}
118 }
114
119
115#[test]
120 #[test]
116fn tarball_script_classic_three_args_still_works() {
121 fn tarball_script_classic_three_args_still_works() {
117 let tmp = tempfile::tempdir().unwrap();
122 let tmp = tempfile::tempdir().unwrap();
118 let main_root = tmp.path().join("main");
123 let main_root = tmp.path().join("main");
119 write_fake_usr_tree(&main_root, "only-main");
124 write_fake_usr_tree(&main_root, "only-main");
120 let main_pkg = tmp.path().join("posprint-0.5.7-1-x86_64.pkg.tar");
125 let main_pkg = tmp.path().join("posprint-0.5.7-1-x86_64.pkg.tar");
121 tar_usr(&main_root, &main_pkg);
126 tar_usr(&main_root, &main_pkg);
122 let out = tmp.path().join("out.tar.gz");
127 let out = tmp.path().join("out.tar.gz");
123
128
124 let output = run_tarball_script(&[main_pkg.to_str().unwrap(), out.to_str().unwrap(), "0.5.7"]);
129 let output = run_tarball_script(&[main_pkg.to_str().unwrap(), out.to_str().unwrap(), "0.5.7"]);
125 assert!(
130 assert!(
126 output.status.success(),
131 output.status.success(),
127 "stderr: {}",
132 "stderr: {}",
128 String::from_utf8_lossy(&output.stderr)
133 String::from_utf8_lossy(&output.stderr)
129 );
134 );
130 assert!(out.is_file());
135 assert!(out.is_file());
131}
136 }
132
137
133#[test]
138 #[test]
134fn publish_release_dry_run_uses_real_filenames() {
139 fn publish_release_dry_run_uses_real_filenames() {
135 let tmp = tempfile::tempdir().unwrap();
140 let tmp = tempfile::tempdir().unwrap();
136 let dist = tmp.path();
141 let dist = tmp.path();
137 fs::write(dist.join("posprint_0.5.7-1_amd64.deb"), b"deb").unwrap();
142 fs::write(dist.join("posprint_0.5.7-1_amd64.deb"), b"deb").unwrap();
138 fs::write(
143 fs::write(
139 dist.join("posprint-0.5.7-1-x86_64.pkg.tar.zst"),
144 dist.join("posprint-0.5.7-1-x86_64.pkg.tar.zst"),
140 b"pkg",
145 b"pkg",
141 )
146 )
142 .unwrap();
147 .unwrap();
143 fs::write(dist.join("posprint-debug-0.5.7-1-x86_64.pkg.tar.zst"), b"dbg").unwrap();
148 fs::write(dist.join("posprint-debug-0.5.7-1-x86_64.pkg.tar.zst"), b"dbg").unwrap();
144 fs::write(dist.join("posprint-0.5.7-x86_64.tar.gz"), b"tgz").unwrap();
149 fs::write(dist.join("posprint-0.5.7-x86_64.tar.gz"), b"tgz").unwrap();
145 fs::write(dist.join("posprint.exe"), b"exe").unwrap();
150 fs::write(dist.join("posprint.exe"), b"exe").unwrap();
146
151
147 let output = run_publish_release(&[
152 let output = run_publish_release(&[
148 "--dry-run",
153 "--dry-run",
149 "--dist",
154 "--dist",
150 dist.to_str().unwrap(),
155 dist.to_str().unwrap(),
151 "0.5.7",
156 "0.5.7",
152 ]);
157 ]);
153 assert!(
158 assert!(
154 output.status.success(),
159 output.status.success(),
155 "stdout:\n{}\nstderr:\n{}",
160 "stdout:\n{}\nstderr:\n{}",
156 String::from_utf8_lossy(&output.stdout),
161 String::from_utf8_lossy(&output.stdout),
157 String::from_utf8_lossy(&output.stderr)
162 String::from_utf8_lossy(&output.stderr)
158 );
163 );
159 let stdout = String::from_utf8_lossy(&output.stdout);
164 let stdout = String::from_utf8_lossy(&output.stdout);
160 assert!(stdout.contains("posprint_0.5.7-1_amd64.deb"));
165 assert!(stdout.contains("posprint_0.5.7-1_amd64.deb"));
161 assert!(stdout.contains("posprint-0.5.7-1-x86_64.pkg.tar.zst"));
166 assert!(stdout.contains("posprint-0.5.7-1-x86_64.pkg.tar.zst"));
162 assert!(
167 assert!(
163 !stdout.contains("posprint-debug-"),
168 !stdout.contains("posprint-debug-"),
164 "debug package must not be a release asset:\n{stdout}"
169 "debug package must not be a release asset:\n{stdout}"
165 );
170 );
166 assert!(
171 assert!(
167 !stdout.contains("posprint_0.5.7-1-x86_64"),
172 !stdout.contains("posprint_0.5.7-1-x86_64"),
168 "Arch package must use hyphens, not posprint_ver:\n{stdout}"
173 "Arch package must use hyphens, not posprint_ver:\n{stdout}"
169 );
174 );
170 assert!(stdout.contains("posprint-0.5.7-x86_64.tar.gz"));
175 assert!(stdout.contains("posprint-0.5.7-x86_64.tar.gz"));
171 assert!(stdout.contains("posprint.exe"));
176 assert!(stdout.contains("posprint.exe"));
172}
177 }
173
178
174#[test]
179 #[test]
175fn publish_release_dry_run_rejects_missing_tarball() {
180 fn publish_release_dry_run_rejects_missing_tarball() {
176 let tmp = tempfile::tempdir().unwrap();
181 let tmp = tempfile::tempdir().unwrap();
177 let dist = tmp.path();
182 let dist = tmp.path();
178 fs::write(dist.join("posprint_0.5.7-1_amd64.deb"), b"deb").unwrap();
183 fs::write(dist.join("posprint_0.5.7-1_amd64.deb"), b"deb").unwrap();
179 fs::write(
184 fs::write(
180 dist.join("posprint-0.5.7-1-x86_64.pkg.tar.zst"),
185 dist.join("posprint-0.5.7-1-x86_64.pkg.tar.zst"),
181 b"pkg",
186 b"pkg",
182 )
187 )
183 .unwrap();
188 .unwrap();
184 fs::write(dist.join("posprint.exe"), b"exe").unwrap();
189 fs::write(dist.join("posprint.exe"), b"exe").unwrap();
185
190
186 let output = run_publish_release(&[
191 let output = run_publish_release(&[
187 "--dry-run",
192 "--dry-run",
188 "--dist",
193 "--dist",
189 dist.to_str().unwrap(),
194 dist.to_str().unwrap(),
190 "0.5.7",
195 "0.5.7",
191 ]);
196 ]);
192 assert!(!output.status.success());
197 assert!(!output.status.success());
193 let stderr = String::from_utf8_lossy(&output.stderr);
198 let stderr = String::from_utf8_lossy(&output.stderr);
194 assert!(
199 assert!(
195 stderr.contains("tar.gz"),
200 stderr.contains("tar.gz"),
196 "expected missing-tarball error, got: {stderr}"
201 "expected missing-tarball error, got: {stderr}"
197 );
202 );
203 }
198}
204}
199
205
200#[test]
206#[test]