126 lines
3.8 KiB
Rust
126 lines
3.8 KiB
Rust
use codex_utils_cargo_bin::repo_root;
|
|
use pretty_assertions::assert_eq;
|
|
use std::collections::BTreeMap;
|
|
use std::fs;
|
|
use std::path::Path;
|
|
use std::path::PathBuf;
|
|
use std::process::Command;
|
|
use tempfile::tempdir;
|
|
|
|
#[test]
|
|
fn test_apply_patch_scenarios() -> anyhow::Result<()> {
|
|
let scenarios_dir = repo_root()?
|
|
.join("codex-rs")
|
|
.join("apply-patch")
|
|
.join("tests")
|
|
.join("fixtures")
|
|
.join("scenarios");
|
|
for scenario in fs::read_dir(scenarios_dir)? {
|
|
let scenario = scenario?;
|
|
let path = scenario.path();
|
|
if path.is_dir() {
|
|
run_apply_patch_scenario(&path)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// Reads a scenario directory, copies the input files to a temporary directory, runs apply-patch,
|
|
/// and asserts that the final state matches the expected state exactly.
|
|
fn run_apply_patch_scenario(dir: &Path) -> anyhow::Result<()> {
|
|
let tmp = tempdir()?;
|
|
|
|
// Copy the input files to the temporary directory
|
|
let input_dir = dir.join("input");
|
|
if input_dir.is_dir() {
|
|
copy_dir_recursive(&input_dir, tmp.path())?;
|
|
}
|
|
|
|
// Read the patch.txt file
|
|
let patch = fs::read_to_string(dir.join("patch.txt"))?;
|
|
|
|
// Run apply_patch in the temporary directory. We intentionally do not assert
|
|
// on the exit status here; the scenarios are specified purely in terms of
|
|
// final filesystem state, which we compare below.
|
|
Command::new(codex_utils_cargo_bin::cargo_bin("apply_patch")?)
|
|
.arg(patch)
|
|
.current_dir(tmp.path())
|
|
.output()?;
|
|
|
|
// Assert that the final state matches the expected state exactly
|
|
let expected_dir = dir.join("expected");
|
|
let expected_snapshot = snapshot_dir(&expected_dir)?;
|
|
let actual_snapshot = snapshot_dir(tmp.path())?;
|
|
|
|
assert_eq!(
|
|
actual_snapshot,
|
|
expected_snapshot,
|
|
"Scenario {} did not match expected final state",
|
|
dir.display()
|
|
);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
enum Entry {
|
|
File(Vec<u8>),
|
|
Dir,
|
|
}
|
|
|
|
fn snapshot_dir(root: &Path) -> anyhow::Result<BTreeMap<PathBuf, Entry>> {
|
|
let mut entries = BTreeMap::new();
|
|
if root.is_dir() {
|
|
snapshot_dir_recursive(root, root, &mut entries)?;
|
|
}
|
|
Ok(entries)
|
|
}
|
|
|
|
fn snapshot_dir_recursive(
|
|
base: &Path,
|
|
dir: &Path,
|
|
entries: &mut BTreeMap<PathBuf, Entry>,
|
|
) -> anyhow::Result<()> {
|
|
for entry in fs::read_dir(dir)? {
|
|
let entry = entry?;
|
|
let path = entry.path();
|
|
let Some(stripped) = path.strip_prefix(base).ok() else {
|
|
continue;
|
|
};
|
|
let rel = stripped.to_path_buf();
|
|
|
|
// Under Buck2, files in `__srcs` are often materialized as symlinks.
|
|
// Use `metadata()` (follows symlinks) so our fixture snapshots work
|
|
// under both Cargo and Buck2.
|
|
let metadata = fs::metadata(&path)?;
|
|
if metadata.is_dir() {
|
|
entries.insert(rel.clone(), Entry::Dir);
|
|
snapshot_dir_recursive(base, &path, entries)?;
|
|
} else if metadata.is_file() {
|
|
let contents = fs::read(&path)?;
|
|
entries.insert(rel, Entry::File(contents));
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn copy_dir_recursive(src: &Path, dst: &Path) -> anyhow::Result<()> {
|
|
for entry in fs::read_dir(src)? {
|
|
let entry = entry?;
|
|
let path = entry.path();
|
|
let dest_path = dst.join(entry.file_name());
|
|
|
|
// See note in `snapshot_dir_recursive` about Buck2 symlink trees.
|
|
let metadata = fs::metadata(&path)?;
|
|
if metadata.is_dir() {
|
|
fs::create_dir_all(&dest_path)?;
|
|
copy_dir_recursive(&path, &dest_path)?;
|
|
} else if metadata.is_file() {
|
|
if let Some(parent) = dest_path.parent() {
|
|
fs::create_dir_all(parent)?;
|
|
}
|
|
fs::copy(&path, &dest_path)?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|