Skip to content

Commit 4b9c09b

Browse files
nayuta-ainayuta-ai
committed
refactor net_devices tests to use unique device names for better isolation and reliability.
Signed-off-by: nayuta-ai <[email protected]>
1 parent 2424422 commit 4b9c09b

File tree

1 file changed

+52
-45
lines changed

1 file changed

+52
-45
lines changed

‎tests/contest/contest/src/tests/net_devices/net_devices_test.rs

Lines changed: 52 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -13,12 +13,18 @@ use crate::utils::test_utils::{check_container_created, CreateOptions};
1313
use crate::utils::{test_inside_container, test_outside_container};
1414

1515
static NETNS_COUNTER: AtomicUsize = AtomicUsize::new(0);
16+
static DEVICE_COUNTER: AtomicUsize = AtomicUsize::new(0);
1617

1718
fn create_unique_netns_name(prefix: &str) -> String {
1819
let count = NETNS_COUNTER.fetch_add(1, Ordering::SeqCst);
1920
format!("{}-{}", prefix, count)
2021
}
2122

23+
pub fn create_unique_device_name(prefix: &str) -> String {
24+
let count = DEVICE_COUNTER.fetch_add(1, Ordering::SeqCst);
25+
format!("{}-{}", prefix, count)
26+
}
27+
2228
fn create_netns(name: &str) -> Result<()> {
2329
std::process::Command::new("ip")
2430
.args(vec!["netns", "add", name])
@@ -90,104 +96,104 @@ fn create_spec_with_netns(net_devices: HashMap<String, LinuxNetDevice>, netns: S
9096
}
9197

9298
fn check_net_device() -> TestResult {
93-
const DUMMY_DEVICE: &str = "dummy";
99+
let device_name = create_unique_device_name("dummy");
94100

95-
if let Err(e) = create_dummy_device(DUMMY_DEVICE) {
101+
if let Err(e) = create_dummy_device(&device_name) {
96102
return TestResult::Failed(anyhow!("Failed to create dummy device: {}", e));
97103
}
98104

99105
let mut net_devices = HashMap::new();
100-
net_devices.insert(DUMMY_DEVICE.to_string(), LinuxNetDevice::default());
106+
net_devices.insert(device_name.clone(), LinuxNetDevice::default());
101107
let spec = create_spec(net_devices);
102108
test_inside_container(&spec, &CreateOptions::default(), &|_| Ok(()));
103109

104-
match check_device_exists(DUMMY_DEVICE) {
110+
match check_device_exists(&device_name) {
105111
Ok(true) => {
106-
if let Err(e) = delete_dummy_device(DUMMY_DEVICE) {
112+
if let Err(e) = delete_dummy_device(&device_name) {
107113
return TestResult::Failed(anyhow!("Failed to delete device: {}", e));
108114
}
109-
return TestResult::Failed(anyhow!("Device still exists after test"));
115+
TestResult::Failed(anyhow!("The device still exists after test"))
110116
}
111117
Ok(false) => TestResult::Passed,
112118
Err(e) => {
113-
if let Err(e) = delete_dummy_device(DUMMY_DEVICE) {
119+
if let Err(e) = delete_dummy_device(&device_name) {
114120
return TestResult::Failed(anyhow!("Failed to delete device: {}", e));
115121
}
116-
return TestResult::Failed(anyhow!("Failed to check device: {}", e));
122+
TestResult::Failed(anyhow!("Failed to check device: {}", e))
117123
}
118124
}
119125
}
120126

121127
fn check_net_device_rename() -> TestResult {
122-
const DUMMY_DEVICE: &str = "dummy-rename";
123-
const DUMMY_DEVICE_RENAMED: &str = "dummy1-renamed";
128+
let device_name = create_unique_device_name("dummy-rename");
129+
let device_name_rename = create_unique_device_name("dummy-renamed");
124130

125-
if let Err(e) = create_dummy_device(DUMMY_DEVICE) {
131+
if let Err(e) = create_dummy_device(&device_name) {
126132
return TestResult::Failed(anyhow!("Failed to create dummy device: {}", e));
127133
}
128134

129135
let mut net_devices = HashMap::new();
130136
net_devices.insert(
131-
DUMMY_DEVICE.to_string(),
137+
device_name.clone(),
132138
LinuxNetDeviceBuilder::default()
133-
.name(DUMMY_DEVICE_RENAMED)
139+
.name(&device_name_rename)
134140
.build()
135141
.unwrap(),
136142
);
137143
let spec = create_spec(net_devices);
138144
test_inside_container(&spec, &CreateOptions::default(), &|_| Ok(()));
139145

140-
match check_device_exists(DUMMY_DEVICE) {
146+
match check_device_exists(&device_name) {
141147
Ok(true) => {
142-
if let Err(e) = delete_dummy_device(DUMMY_DEVICE) {
148+
if let Err(e) = delete_dummy_device(&device_name) {
143149
return TestResult::Failed(anyhow!("Failed to delete device: {}", e));
144150
}
145-
return TestResult::Failed(anyhow!("Device still exists after test"));
151+
TestResult::Failed(anyhow!("The device still exists after test"))
146152
}
147153
Ok(false) => TestResult::Passed,
148154
Err(e) => {
149-
if let Err(e) = delete_dummy_device(DUMMY_DEVICE) {
155+
if let Err(e) = delete_dummy_device(&device_name) {
150156
return TestResult::Failed(anyhow!("Failed to delete device: {}", e));
151157
}
152-
return TestResult::Failed(anyhow!("Failed to check device: {}", e));
158+
TestResult::Failed(anyhow!("Failed to check device: {}", e))
153159
}
154160
}
155161
}
156162

157163
fn check_net_devices() -> TestResult {
158-
const DUMMY_DEVICE1: &str = "dummy1";
159-
const DUMMY_DEVICE2: &str = "dummy2";
164+
let device_name1 = create_unique_device_name("dummy1");
165+
let device_name2 = create_unique_device_name("dummy2");
160166

161-
if let Err(e) = create_dummy_device(DUMMY_DEVICE1) {
167+
if let Err(e) = create_dummy_device(&device_name1) {
162168
return TestResult::Failed(anyhow!("Failed to create dummy device: {}", e));
163169
}
164170

165-
if let Err(e) = create_dummy_device(DUMMY_DEVICE2) {
171+
if let Err(e) = create_dummy_device(&device_name2) {
166172
return TestResult::Failed(anyhow!("Failed to create dummy device: {}", e));
167173
}
168174

169175
let mut net_devices = HashMap::new();
170-
net_devices.insert(DUMMY_DEVICE1.to_string(), LinuxNetDevice::default());
171-
net_devices.insert(DUMMY_DEVICE2.to_string(), LinuxNetDevice::default());
176+
net_devices.insert(device_name1.clone(), LinuxNetDevice::default());
177+
net_devices.insert(device_name2.clone(), LinuxNetDevice::default());
172178
let spec = create_spec(net_devices);
173179
test_inside_container(&spec, &CreateOptions::default(), &|_| Ok(()));
174180

175181
let mut result = TestResult::Passed;
176182

177-
match check_device_exists(DUMMY_DEVICE1) {
183+
match check_device_exists(&device_name1) {
178184
Ok(true) => {
179-
result = TestResult::Failed(anyhow!("Device1 still exists after test"));
185+
result = TestResult::Failed(anyhow!("The device1 still exists after test"));
180186
}
181187
Ok(false) => {}
182188
Err(e) => {
183189
result = TestResult::Failed(anyhow!("Failed to check device1: {}", e));
184190
}
185191
}
186192

187-
match check_device_exists(DUMMY_DEVICE2) {
193+
match check_device_exists(&device_name2) {
188194
Ok(true) => {
189195
if let TestResult::Passed = result {
190-
result = TestResult::Failed(anyhow!("Device2 still exists after test"));
196+
result = TestResult::Failed(anyhow!("The device2 still exists after test"));
191197
}
192198
}
193199
Ok(false) => {}
@@ -199,16 +205,17 @@ fn check_net_devices() -> TestResult {
199205
}
200206

201207
// cleanup both devices regardless of test result
202-
let _ = delete_dummy_device(DUMMY_DEVICE1);
203-
let _ = delete_dummy_device(DUMMY_DEVICE2);
208+
let _ = delete_dummy_device(&device_name1);
209+
let _ = delete_dummy_device(&device_name2);
204210

205211
result
206212
}
207213

208214
fn check_empty_net_devices() -> TestResult {
209-
const DUMMY_DEVICE: &str = "dummy-empty";
215+
let device_name = create_unique_device_name("dummy-empty");
216+
210217
let mut net_devices = HashMap::new();
211-
net_devices.insert(DUMMY_DEVICE.to_string(), LinuxNetDevice::default());
218+
net_devices.insert(device_name.clone(), LinuxNetDevice::default());
212219
let spec = create_spec(net_devices);
213220
let result = test_inside_container(&spec, &CreateOptions::default(), &|_| Ok(()));
214221

@@ -224,13 +231,13 @@ fn check_empty_net_devices() -> TestResult {
224231

225232
fn check_back_device() -> TestResult {
226233
let netns_name = create_unique_netns_name("netns-back");
227-
const DUMMY_DEVICE: &str = "dummy-back";
234+
let device_name = create_unique_device_name("dummy-back");
228235

229236
let mut net_devices = HashMap::new();
230237
net_devices.insert(
231-
DUMMY_DEVICE.to_string(),
238+
device_name.clone(),
232239
LinuxNetDeviceBuilder::default()
233-
.name(DUMMY_DEVICE.to_string())
240+
.name(&device_name)
234241
.build()
235242
.unwrap(),
236243
);
@@ -239,7 +246,7 @@ fn check_back_device() -> TestResult {
239246
return TestResult::Failed(anyhow!("Failed to create netns: {}", e));
240247
}
241248

242-
if let Err(e) = create_dummy_device(DUMMY_DEVICE) {
249+
if let Err(e) = create_dummy_device(&device_name) {
243250
return TestResult::Failed(anyhow!("Failed to create dummy device: {}", e));
244251
}
245252

@@ -269,7 +276,7 @@ fn check_back_device() -> TestResult {
269276
"link",
270277
"set",
271278
"dev",
272-
DUMMY_DEVICE,
279+
&device_name,
273280
"netns",
274281
"1",
275282
])
@@ -279,11 +286,11 @@ fn check_back_device() -> TestResult {
279286
}
280287

281288
// Check that the device exists
282-
if let Err(e) = check_device_exists(DUMMY_DEVICE) {
289+
if let Err(e) = check_device_exists(&device_name) {
283290
return TestResult::Failed(anyhow!("Failed to check device: {}", e));
284291
}
285292

286-
if let Err(e) = delete_dummy_device(DUMMY_DEVICE) {
293+
if let Err(e) = delete_dummy_device(&device_name) {
287294
return TestResult::Failed(anyhow!("Failed to delete device: {}", e));
288295
}
289296

@@ -296,14 +303,14 @@ fn check_back_device() -> TestResult {
296303

297304
fn check_address() -> TestResult {
298305
let netns_name = create_unique_netns_name("netns-address");
299-
const DUMMY_DEVICE: &str = "dummy-address";
306+
let device_name = create_unique_device_name("dummy-address");
300307
const DUMMY_ADDRESS: &str = "244.178.44.111/24";
301308

302309
let mut net_devices = HashMap::new();
303310
net_devices.insert(
304-
DUMMY_DEVICE.to_string(),
311+
device_name.clone(),
305312
LinuxNetDeviceBuilder::default()
306-
.name(DUMMY_DEVICE.to_string())
313+
.name(&device_name)
307314
.build()
308315
.unwrap(),
309316
);
@@ -312,13 +319,13 @@ fn check_address() -> TestResult {
312319
return TestResult::Failed(anyhow!("Failed to create netns: {}", e));
313320
}
314321

315-
if let Err(e) = create_dummy_device(DUMMY_DEVICE) {
322+
if let Err(e) = create_dummy_device(&device_name) {
316323
return TestResult::Failed(anyhow!("Failed to create dummy device: {}", e));
317324
}
318325

319326
// Add address to the device
320327
if let Err(e) = std::process::Command::new("ip")
321-
.args(vec!["addr", "add", DUMMY_ADDRESS, "dev", DUMMY_DEVICE])
328+
.args(vec!["addr", "add", DUMMY_ADDRESS, "dev", &device_name])
322329
.output()
323330
{
324331
return TestResult::Failed(anyhow!("Failed to add address: {}", e));
@@ -352,7 +359,7 @@ fn check_address() -> TestResult {
352359
Ok(out) => out,
353360
Err(e) => return TestResult::Failed(anyhow!("Failed to parse output: {}", e)),
354361
};
355-
if !out.contains(DUMMY_DEVICE) || !out.contains(DUMMY_ADDRESS) {
362+
if !out.contains(&device_name) || !out.contains(DUMMY_ADDRESS) {
356363
return TestResult::Failed(anyhow!("Address not found in output"));
357364
}
358365

0 commit comments

Comments
 (0)