Testing a small http-client on Linux using no_std & embedded reqwless.
Refactor xtask validation around backend and DNS combos
Refs: reqwl-dns-mode-features
Refs: reqwl-backend-feature-matrix
+126
-70
+126
-70
xtask/src/validate.rs
+126
-70
xtask/src/validate.rs
···
4
4
use std::process::Command;
5
5
6
6
const DNS_IP_ONLY_REJECT_NEEDLE: &str = "dns-ip-only mode accepts literal IP hosts only";
7
+
const HTTP_EXAMPLE_URL: &str = "http://example.com";
8
+
9
+
#[derive(Clone, Copy)]
10
+
enum BackendFeature {
11
+
PosixLibc,
12
+
Rustix,
13
+
}
14
+
15
+
impl BackendFeature {
16
+
const fn feature(self) -> &'static str {
17
+
match self {
18
+
Self::PosixLibc => "backend-posix-libc",
19
+
Self::Rustix => "backend-rustix",
20
+
}
21
+
}
22
+
}
23
+
24
+
#[derive(Clone, Copy)]
25
+
enum DnsFeature {
26
+
GetAddrInfo,
27
+
IpOnly,
28
+
}
29
+
30
+
impl DnsFeature {
31
+
const fn feature(self) -> &'static str {
32
+
match self {
33
+
Self::GetAddrInfo => "dns-getaddrinfo",
34
+
Self::IpOnly => "dns-ip-only",
35
+
}
36
+
}
37
+
}
38
+
39
+
#[derive(Clone, Copy)]
40
+
struct FeatureCombo {
41
+
backend: BackendFeature,
42
+
dns: DnsFeature,
43
+
}
44
+
45
+
impl FeatureCombo {
46
+
const fn new(backend: BackendFeature, dns: DnsFeature) -> Self {
47
+
Self { backend, dns }
48
+
}
49
+
50
+
fn feature_arg(self) -> String {
51
+
format!("{},{}", self.backend.feature(), self.dns.feature())
52
+
}
53
+
54
+
fn check_display(self) -> String {
55
+
format!(
56
+
"cargo check --no-default-features --features {}",
57
+
self.feature_arg()
58
+
)
59
+
}
60
+
61
+
fn check_args(self) -> Vec<String> {
62
+
let features = self.feature_arg();
63
+
vec![
64
+
"check".to_owned(),
65
+
"--no-default-features".to_owned(),
66
+
"--features".to_owned(),
67
+
features,
68
+
]
69
+
}
70
+
71
+
fn run_display(self, url: &str) -> String {
72
+
format!(
73
+
"cargo run --no-default-features --features {} -- {}",
74
+
self.feature_arg(),
75
+
url
76
+
)
77
+
}
78
+
79
+
fn run_args(self, url: &str) -> Vec<String> {
80
+
let features = self.feature_arg();
81
+
vec![
82
+
"run".to_owned(),
83
+
"--no-default-features".to_owned(),
84
+
"--features".to_owned(),
85
+
features,
86
+
"--".to_owned(),
87
+
url.to_owned(),
88
+
]
89
+
}
90
+
}
7
91
8
92
#[derive(Clone, Copy, clap::ValueEnum)]
9
93
pub enum ValidateTask {
···
41
125
}
42
126
43
127
fn run_validate_task(task: ValidateTask) -> Result<(), String> {
128
+
let posix_ip_only = FeatureCombo::new(BackendFeature::PosixLibc, DnsFeature::IpOnly);
129
+
let rustix_getaddrinfo = FeatureCombo::new(BackendFeature::Rustix, DnsFeature::GetAddrInfo);
130
+
let rustix_ip_only = FeatureCombo::new(BackendFeature::Rustix, DnsFeature::IpOnly);
131
+
44
132
match task {
45
133
ValidateTask::All => run_sequence(&[
46
134
ValidateTask::Check,
···
66
154
ValidateTask::RunIpOnlyReject,
67
155
ValidateTask::RunRustixIpOnlyReject,
68
156
]),
69
-
ValidateTask::Check => run_success("cargo check", &["check"]),
70
-
ValidateTask::CheckHttps => {
71
-
run_success("cargo check --features https", &["check", "--features", "https"])
72
-
}
73
-
ValidateTask::CheckIpOnly => run_success(
74
-
"cargo check --no-default-features --features backend-posix-libc,dns-ip-only",
75
-
&[
76
-
"check",
77
-
"--no-default-features",
78
-
"--features",
79
-
"backend-posix-libc,dns-ip-only",
80
-
],
81
-
),
82
-
ValidateTask::RunHttpExample => {
83
-
run_success("cargo run -- http://example.com", &["run", "--", "http://example.com"])
84
-
}
85
-
ValidateTask::RunIpOnlyReject => run_expected_failure(
86
-
"cargo run --no-default-features --features backend-posix-libc,dns-ip-only -- http://example.com",
87
-
&[
88
-
"run",
89
-
"--no-default-features",
90
-
"--features",
91
-
"backend-posix-libc,dns-ip-only",
92
-
"--",
93
-
"http://example.com",
94
-
],
95
-
DNS_IP_ONLY_REJECT_NEEDLE,
96
-
),
97
-
ValidateTask::CheckRustix => run_success(
98
-
"cargo check --no-default-features --features backend-rustix,dns-getaddrinfo",
99
-
&[
100
-
"check",
101
-
"--no-default-features",
102
-
"--features",
103
-
"backend-rustix,dns-getaddrinfo",
104
-
],
105
-
),
106
-
ValidateTask::CheckRustixIpOnly => run_success(
107
-
"cargo check --no-default-features --features backend-rustix,dns-ip-only",
108
-
&[
109
-
"check",
110
-
"--no-default-features",
111
-
"--features",
112
-
"backend-rustix,dns-ip-only",
113
-
],
114
-
),
115
-
ValidateTask::RunRustixHttpExample => run_success(
116
-
"cargo run --no-default-features --features backend-rustix,dns-getaddrinfo -- http://example.com",
117
-
&[
118
-
"run",
119
-
"--no-default-features",
120
-
"--features",
121
-
"backend-rustix,dns-getaddrinfo",
122
-
"--",
123
-
"http://example.com",
124
-
],
157
+
ValidateTask::Check => run_success("cargo check", &cargo_args(&["check"])),
158
+
ValidateTask::CheckHttps => run_success(
159
+
"cargo check --features https",
160
+
&cargo_args(&["check", "--features", "https"]),
125
161
),
126
-
ValidateTask::RunRustixIpOnlyReject => run_expected_failure(
127
-
"cargo run --no-default-features --features backend-rustix,dns-ip-only -- http://example.com",
128
-
&[
129
-
"run",
130
-
"--no-default-features",
131
-
"--features",
132
-
"backend-rustix,dns-ip-only",
133
-
"--",
134
-
"http://example.com",
135
-
],
136
-
DNS_IP_ONLY_REJECT_NEEDLE,
162
+
ValidateTask::CheckIpOnly => run_check_combo(posix_ip_only),
163
+
ValidateTask::RunHttpExample => run_success(
164
+
"cargo run -- http://example.com",
165
+
&cargo_args(&["run", "--", HTTP_EXAMPLE_URL]),
137
166
),
167
+
ValidateTask::RunIpOnlyReject => run_ip_only_reject_combo(posix_ip_only),
168
+
ValidateTask::CheckRustix => run_check_combo(rustix_getaddrinfo),
169
+
ValidateTask::CheckRustixIpOnly => run_check_combo(rustix_ip_only),
170
+
ValidateTask::RunRustixHttpExample => run_http_example_combo(rustix_getaddrinfo),
171
+
ValidateTask::RunRustixIpOnlyReject => run_ip_only_reject_combo(rustix_ip_only),
138
172
}
139
173
}
140
174
175
+
fn run_check_combo(combo: FeatureCombo) -> Result<(), String> {
176
+
let display = combo.check_display();
177
+
let args = combo.check_args();
178
+
run_success(&display, &args)
179
+
}
180
+
181
+
fn run_http_example_combo(combo: FeatureCombo) -> Result<(), String> {
182
+
let display = combo.run_display(HTTP_EXAMPLE_URL);
183
+
let args = combo.run_args(HTTP_EXAMPLE_URL);
184
+
run_success(&display, &args)
185
+
}
186
+
187
+
fn run_ip_only_reject_combo(combo: FeatureCombo) -> Result<(), String> {
188
+
let display = combo.run_display(HTTP_EXAMPLE_URL);
189
+
let args = combo.run_args(HTTP_EXAMPLE_URL);
190
+
run_expected_failure(&display, &args, DNS_IP_ONLY_REJECT_NEEDLE)
191
+
}
192
+
141
193
fn run_sequence(tasks: &[ValidateTask]) -> Result<(), String> {
142
194
for task in tasks {
143
195
run_validate_task(*task)?;
···
145
197
Ok(())
146
198
}
147
199
148
-
fn run_success(display: &str, cargo_args: &[&str]) -> Result<(), String> {
200
+
fn run_success(display: &str, cargo_args: &[String]) -> Result<(), String> {
149
201
eprintln!("==> {display}");
150
202
let output = run_cargo(cargo_args)?;
151
203
if output.status.success() {
···
158
210
))
159
211
}
160
212
161
-
fn run_expected_failure(display: &str, cargo_args: &[&str], needle: &str) -> Result<(), String> {
213
+
fn run_expected_failure(display: &str, cargo_args: &[String], needle: &str) -> Result<(), String> {
162
214
eprintln!("==> {display}");
163
215
let output = run_cargo(cargo_args)?;
164
216
if output.status.success() {
···
177
229
))
178
230
}
179
231
180
-
fn run_cargo(cargo_args: &[&str]) -> Result<std::process::Output, String> {
232
+
fn run_cargo(cargo_args: &[String]) -> Result<std::process::Output, String> {
181
233
Command::new("cargo")
182
234
.current_dir(workspace_root())
183
235
.args(cargo_args)
184
236
.output()
185
237
.map_err(|error| format!("failed to execute cargo: {error}"))
238
+
}
239
+
240
+
fn cargo_args(parts: &[&str]) -> Vec<String> {
241
+
parts.iter().map(|part| (*part).to_owned()).collect()
186
242
}
187
243
188
244
fn workspace_root() -> &'static Path {