Restore inline mtime; stabilize list_files test

Author: octoaide[bot]

src/root/ifconfig.rs

@@ -5,7 +5,6 @@ use std::{
     io::{Read, Write},
     net::IpAddr,
     process::Command,
-    time::SystemTime,
 };
 
 use anyhow::{Result, anyhow};
@@ -429,13 +428,17 @@ fn list_files(
     for path in paths.flatten() {
         let filepath = path.path();
         let metadata = fs::metadata(filepath)?;
-        let modified = format_modified_time(metadata.modified()?);
+        let modified: DateTime<Local> = metadata.modified()?.into();
 
         if let Some(filename) = path.path().file_name()
             && let Some(filename) = filename.to_str()
         {
             if metadata.is_file() {
-                files.push((metadata.len(), modified, filename.to_string()));
+                files.push((
+                    metadata.len(),
+                    format!("{}", modified.format("%Y/%m/%d %T")),
+                    filename.to_string(),
+                ));
             } else if subdir && metadata.is_dir() {
                 files.push((0, String::new(), filename.to_string()));
                 /*
@@ -458,13 +461,6 @@ fn list_files(
     Ok(files)
 }
 
-// Formats a file modification time as local time in the pattern
-// "YYYY/MM/DD HH:MM:SS".
-fn format_modified_time(modified: SystemTime) -> String {
-    let modified: DateTime<Local> = modified.into();
-    modified.format("%Y/%m/%d %T").to_string()
-}
-
 fn run_command(cmd: &str, args: &[&str]) -> Result<bool> {
     let status = Command::new(cmd)
         .env("PATH", "/usr/sbin:/usr/bin:/sbin:/bin")
@@ -688,23 +684,57 @@ mod tests {
         fs::remove_dir_all(&dir).expect("temp test directory should be removable");
     }
 
+    const LIST_FILES_MTIME_CHILD_ENV: &str = "ROXY_LIST_FILES_MTIME_CHILD";
+
     #[test]
     fn list_files_formats_modified_time_in_local_timezone() {
-        // SAFETY: TZ is mutated process-wide. We force UTC so that the
-        // local-time formatting in `list_files` is deterministic across CI
-        // and developer machines, regardless of the host's actual zone.
-        unsafe {
-            std::env::set_var("TZ", "UTC");
+        if std::env::var_os(LIST_FILES_MTIME_CHILD_ENV).is_some() {
+            let dir = make_temp_test_dir("list-mtime");
+            let file_path = dir.join("fixed.yaml");
+            write_text_file(&file_path, "fixed");
+
+            let ts = UNIX_EPOCH + Duration::from_secs(1_700_000_000);
+            let file = OpenOptions::new()
+                .write(true)
+                .open(&file_path)
+                .expect("test file should be openable for timestamp update");
+            file.set_modified(ts)
+                .expect("test file modified time should be settable");
+
+            let listed = list_files(
+                dir.to_str().expect("temp path should be valid utf-8"),
+                None,
+                false,
+            )
+            .expect("listing files should succeed");
+            assert_eq!(
+                listed,
+                vec![(
+                    5,
+                    "2023/11/14 22:13:20".to_string(),
+                    "fixed.yaml".to_string()
+                )]
+            );
+
+            fs::remove_dir_all(&dir).expect("temp test directory should be removable");
+            return;
         }
 
-        // 1_700_000_000 seconds after the Unix epoch is
-        // 2023-11-14 22:13:20 UTC. With TZ=UTC, local time equals UTC.
-        let ts = UNIX_EPOCH + Duration::from_secs(1_700_000_000);
-        assert_eq!(format_modified_time(ts), "2023/11/14 22:13:20");
+        let output = std::process::Command::new(
+            std::env::current_exe().expect("current test executable should be available"),
+        )
+        .arg("list_files_formats_modified_time_in_local_timezone")
+        .env(LIST_FILES_MTIME_CHILD_ENV, "1")
+        .env("TZ", "UTC")
+        .output()
+        .expect("child test process should run");
 
-        // Verify the format width is fixed: 4+1+2+1+2+1+2+1+2+1+2 = 19 chars.
-        assert_eq!(format_modified_time(UNIX_EPOCH).len(), 19);
-        assert_eq!(format_modified_time(UNIX_EPOCH), "1970/01/01 00:00:00");
+        assert!(
+            output.status.success(),
+            "child test process should pass\nstdout:\n{}\nstderr:\n{}",
+            String::from_utf8_lossy(&output.stdout),
+            String::from_utf8_lossy(&output.stderr)
+        );
     }
 
     #[test]