1. 1//! The managed install lifecycle, driven as a real user drives it: by
2. 2//! running the `vak` binary, not by calling into its modules.
3. 3//!
4. 4//! Everything here is about a property the unit tests structurally cannot
5. 5//! reach — what happens when the binary performing an operation is *itself*
6. 6//! inside the prefix that operation rewrites. A module-level test always
7. 7//! runs from `target/debug/deps/`, which is never the install root, so the
8. 8//! interesting case never occurred.
9. 9//!
10. 10//! It is not a hypothetical. `self reinstall`, run from the installed CLI —
11. 11//! which is the `vak` on a person's PATH, and therefore the overwhelmingly
12. 12//! common invocation — used to clear the prefix, fail to find the source it
13. 13//! had just deleted, and leave the install EMPTY. The repair command
14. 14//! destroyed the thing it repairs.
15. 15
16. 16#![allow(clippy::expect_used, clippy::unwrap_used)]
17. 17
18. 18use std::path::{Path, PathBuf};
19. 19use std::process::Command;
20. 20
21. 21fn build_cli() -> PathBuf {
22. 22 PathBuf::from(env!("CARGO_BIN_EXE_vak"))
23. 23}
24. 24
25. 25/// Run a `vak self …` subcommand and return (exit code, stdout+stderr).
26. 26fn run(cli: &Path, args: &[&str]) -> (i32, String) {
27. 27 let out = Command::new(cli)
28. 28 .args(args)
29. 29 .output()
30. 30 .expect("run the vak binary");
31. 31 let mut text = String::from_utf8_lossy(&out.stdout).into_owned();
32. 32 text.push_str(&String::from_utf8_lossy(&out.stderr));
33. 33 (out.status.code().unwrap_or(-1), text)
34. 34}
35. 35
36. 36fn install_to(prefix: &Path) {
37. 37 let (code, text) = run(
38. 38 &build_cli(),
39. 39 &["self", "install", "--prefix", &prefix.to_string_lossy()],
40. 40 );
41. 41 assert_eq!(code, 0, "install failed: {text}");
42. 42}
43. 43
44. 44/// The regression. Reinstalling from the installed binary must leave a
45. 45/// working install, not a hole where one used to be.
46. 46#[test]
47. 47fn reinstall_from_the_installed_binary_leaves_a_working_install() {
48. 48 let dir = tempfile::tempdir().unwrap();
49. 49 let prefix = dir.path().join("prefix");
50. 50 install_to(&prefix);
51. 51
52. 52 let installed = prefix.join("bin").join("vak");
53. 53 assert!(installed.exists(), "install placed no CLI");
54. 54
55. 55 let (code, text) = run(
56. 56 &installed,
57. 57 &[
58. 58 "self",
59. 59 "reinstall",
60. 60 "--prefix",
61. 61 &prefix.to_string_lossy(),
62. 62 "--yes",
63. 63 ],
64. 64 );
65. 65 assert_eq!(
66. 66 code, 0,
67. 67 "reinstall from the installed binary failed: {text}"
68. 68 );
69. 69
70. 70 assert!(
71. 71 installed.exists(),
72. 72 "reinstall deleted the CLI and did not put it back — the prefix was \
73. 73 cleared while the binary being run was inside it"
74. 74 );
75. 75 let (code, text) = run(&installed, &["--version"]);
76. 76 assert_eq!(code, 0, "the reinstalled CLI does not run: {text}");
77. 77
78. 78 let (code, text) = run(
79. 79 &installed,
80. 80 &["self", "verify", "--prefix", &prefix.to_string_lossy()],
81. 81 );
82. 82 assert_eq!(code, 0, "the reinstalled install does not verify: {text}");
83. 83}
84. 84
85. 85/// Verify has to see through to the filesystem, not just re-read what the
86. 86/// manifest says about itself.
87. 87#[test]
88. 88fn verify_catches_a_component_that_was_tampered_with() {
89. 89 let dir = tempfile::tempdir().unwrap();
90. 90 let prefix = dir.path().join("prefix");
91. 91 install_to(&prefix);
92. 92
93. 93 let victim = prefix.join("bin").join("vak-delivery-worker");
94. 94 if !victim.exists() {
95. 95 // Optional component; nothing to prove on a build without it.
96. 96 return;
97. 97 }
98. 98 let mut bytes = std::fs::read(&victim).unwrap();
99. 99 bytes.push(0);
100. 100 std::fs::write(&victim, bytes).unwrap();
101. 101
102. 102 let (code, text) = run(
103. 103 &build_cli(),
104. 104 &["self", "verify", "--prefix", &prefix.to_string_lossy()],
105. 105 );
106. 106 assert_ne!(code, 0, "verify passed on a tampered component: {text}");
107. 107 assert!(
108. 108 text.contains("vak-delivery-worker"),
109. 109 "verify must name the component it found wrong, got: {text}"
110. 110 );
111. 111}
112. 112
113. 113/// Uninstall is the reverse of install: the prefix goes, the data home
114. 114/// stays. `--purge` is the only thing that touches data, and is not
115. 115/// exercised here for the obvious reason.
116. 116#[test]
117. 117fn uninstall_removes_the_prefix_and_leaves_nothing_behind() {
118. 118 let dir = tempfile::tempdir().unwrap();
119. 119 let prefix = dir.path().join("prefix");
120. 120 install_to(&prefix);
121. 121 assert!(prefix.join("bin").join("vak").exists());
122. 122
123. 123 let (code, text) = run(
124. 124 &build_cli(),
125. 125 &[
126. 126 "self",
127. 127 "uninstall",
128. 128 "--prefix",
129. 129 &prefix.to_string_lossy(),
130. 130 "--yes",
131. 131 ],
132. 132 );
133. 133 assert_eq!(code, 0, "uninstall failed: {text}");
134. 134 assert!(
135. 135 !prefix.exists() || std::fs::read_dir(&prefix).unwrap().next().is_none(),
136. 136 "uninstall left files under {}",
137. 137 prefix.display()
138. 138 );
139. 139 assert!(
140. 140 text.contains("kept"),
141. 141 "uninstall must say that configuration and data were kept, got: {text}"
142. 142 );
143. 143}
144. 144
145. 145/// A fresh install verifies clean. If this ever fails, every other
146. 146/// assertion in this file is measuring the wrong baseline.
147. 147#[test]
148. 148fn a_fresh_install_verifies_clean() {
149. 149 let dir = tempfile::tempdir().unwrap();
150. 150 let prefix = dir.path().join("prefix");
151. 151 install_to(&prefix);
152. 152
153. 153 let (code, text) = run(
154. 154 &build_cli(),
155. 155 &["self", "verify", "--prefix", &prefix.to_string_lossy()],
156. 156 );
157. 157 assert_eq!(code, 0, "a fresh install does not verify: {text}");
158. 158 assert!(text.contains("verifies clean"), "unexpected output: {text}");
159. 159}
160. 160