756-tempfile-testing — Tempfile Testing

pub struct TempDir {
    path: PathBuf,
}

impl Drop for TempDir {
    fn drop(&mut self) {
        let _ = fs::remove_dir_all(&self.path);
    }
}

let with_temp_dir f =
  let dir = Filename.temp_dir "test" "" in
  Fun.protect ~finally:(fun () -> 
    Sys.command (Printf.sprintf "rm -rf %s" dir) |> ignore
  ) (fun () -> f dir)

#![allow(clippy::all)]
//! # Tempfile Testing
//!
//! Testing with temporary files and directories.

use std::fs::{self, File};
use std::io::{Read, Write};
use std::path::{Path, PathBuf};

/// A temporary directory that cleans up on drop
pub struct TempDir {
    path: PathBuf,
}

impl TempDir {
    /// Create a new temporary directory
    pub fn new(prefix: &str) -> std::io::Result<Self> {
        let path = std::env::temp_dir().join(format!(
            "{}-{}-{}",
            prefix,
            std::process::id(),
            std::time::SystemTime::now()
                .duration_since(std::time::UNIX_EPOCH)
                .unwrap()
                .as_nanos()
        ));
        fs::create_dir_all(&path)?;
        Ok(TempDir { path })
    }

    /// Get the path to the temp directory
    pub fn path(&self) -> &Path {
        &self.path
    }

    /// Create a file in the temp directory
    pub fn create_file(&self, name: &str, content: &str) -> std::io::Result<PathBuf> {
        let file_path = self.path.join(name);
        let mut file = File::create(&file_path)?;
        file.write_all(content.as_bytes())?;
        Ok(file_path)
    }

    /// Read a file from the temp directory
    pub fn read_file(&self, name: &str) -> std::io::Result<String> {
        let file_path = self.path.join(name);
        let mut content = String::new();
        File::open(&file_path)?.read_to_string(&mut content)?;
        Ok(content)
    }
}

impl Drop for TempDir {
    fn drop(&mut self) {
        let _ = fs::remove_dir_all(&self.path);
    }
}

/// Process a config file
pub fn process_config(path: &Path) -> std::io::Result<Vec<(String, String)>> {
    let content = fs::read_to_string(path)?;
    let mut pairs = Vec::new();
    for line in content.lines() {
        if let Some((key, value)) = line.split_once('=') {
            pairs.push((key.trim().to_string(), value.trim().to_string()));
        }
    }
    Ok(pairs)
}

/// Write a config file
pub fn write_config(path: &Path, pairs: &[(String, String)]) -> std::io::Result<()> {
    let content: String = pairs
        .iter()
        .map(|(k, v)| format!("{}={}\n", k, v))
        .collect();
    fs::write(path, content)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_temp_dir_created() {
        let temp = TempDir::new("test").unwrap();
        assert!(temp.path().exists());
    }

    #[test]
    fn test_temp_dir_cleanup() {
        let path = {
            let temp = TempDir::new("cleanup").unwrap();
            temp.path().to_path_buf()
        };
        // After drop, directory should be gone
        assert!(!path.exists());
    }

    #[test]
    fn test_create_and_read_file() {
        let temp = TempDir::new("rw").unwrap();
        temp.create_file("test.txt", "Hello, World!").unwrap();
        let content = temp.read_file("test.txt").unwrap();
        assert_eq!(content, "Hello, World!");
    }

    #[test]
    fn test_process_config() {
        let temp = TempDir::new("config").unwrap();
        let path = temp
            .create_file("config.ini", "key1=value1\nkey2=value2\n")
            .unwrap();
        let pairs = process_config(&path).unwrap();
        assert_eq!(pairs.len(), 2);
        assert_eq!(pairs[0], ("key1".to_string(), "value1".to_string()));
    }

    #[test]
    fn test_write_config() {
        let temp = TempDir::new("write").unwrap();
        let path = temp.path().join("out.ini");
        let pairs = vec![
            ("a".to_string(), "1".to_string()),
            ("b".to_string(), "2".to_string()),
        ];
        write_config(&path, &pairs).unwrap();
        let content = fs::read_to_string(&path).unwrap();
        assert!(content.contains("a=1"));
        assert!(content.contains("b=2"));
    }

    #[test]
    fn test_roundtrip() {
        let temp = TempDir::new("roundtrip").unwrap();
        let path = temp.path().join("config.ini");
        let original = vec![
            ("host".to_string(), "localhost".to_string()),
            ("port".to_string(), "8080".to_string()),
        ];
        write_config(&path, &original).unwrap();
        let loaded = process_config(&path).unwrap();
        assert_eq!(original, loaded);
    }
}

(* 756: Tempfile Testing — OCaml *)

let unique_id =
  let counter = ref 0 in
  fun () -> incr counter; !counter

let create_temp_dir () =
  let tmp = Filename.get_temp_dir_name () in
  let name = Printf.sprintf "ocaml_test_%d_%d"
    (Unix.getpid ()) (unique_id ()) in
  let path = Filename.concat tmp name in
  Unix.mkdir path 0o700;
  path

let remove_dir_all path =
  (* Recursively remove directory *)
  let rec rm p =
    let entries = Sys.readdir p in
    Array.iter (fun entry ->
      let full = Filename.concat p entry in
      if Sys.is_directory full then rm full
      else Sys.remove full
    ) entries;
    Unix.rmdir p
  in
  if Sys.file_exists path then rm path

let with_temp_dir f =
  let dir = create_temp_dir () in
  let result = (try Ok (f dir) with e -> Error e) in
  remove_dir_all dir;
  match result with
  | Ok v  -> v
  | Error e -> raise e

let write_file path content =
  let oc = open_out path in
  output_string oc content;
  close_out oc

let read_file path =
  let ic = open_in path in
  let n = in_channel_length ic in
  let s = Bytes.create n in
  really_input ic s 0 n;
  close_in ic;
  Bytes.to_string s

let () =
  (* Test: write and read a file in temp dir *)
  with_temp_dir (fun dir ->
    let file = Filename.concat dir "test.txt" in
    write_file file "Hello, tempfile!";
    let content = read_file file in
    assert (content = "Hello, tempfile!");
    Printf.printf "Temp dir test passed: %s\n" dir
  );

  (* Dir should be cleaned up *)
  Printf.printf "Cleanup: temp dirs removed\n"