| use super::*; |
| struct Dir(PathBuf); |
| impl Dir { |
| fn new() -> Self { |
| for _ in 0..100 { |
| let p = std::env::temp_dir().join(format!( |
| "nanobrush-cli-test-{}-{}", |
| std::process::id(), |
| NEXT_TEMP.fetch_add(1, Ordering::Relaxed) |
| )); |
| match fs::create_dir(&p) { |
| Ok(()) => return Self(p), |
| Err(e) if e.kind() == io::ErrorKind::AlreadyExists => (), |
| Err(e) => panic!("{e}"), |
| } |
| } |
| panic!("temp dir collision") |
| } |
| fn file(&self, name: &str, bytes: &[u8]) -> PathBuf { |
| let p = self.0.join(name); |
| fs::write(&p, bytes).unwrap(); |
| p |
| } |
| } |
| impl Drop for Dir { |
| fn drop(&mut self) { |
| let _ = fs::remove_dir_all(&self.0); |
| } |
| } |
| fn call(args: &[&std::ffi::OsStr]) -> Result<Vec<u8>> { |
| let mut out = Vec::new(); |
| run(args.iter().map(|s| s.to_os_string()), &mut out)?; |
| Ok(out) |
| } |
| const EMPTY: &[u8] = b"world(computedFeatures false)"; |
| #[test] |
| fn inspect_validate_and_both_versions() { |
| let d = Dir::new(); |
| let input = d.file("é space.txt", EMPTY); |
| let summary = call(&["inspect".as_ref(), input.as_os_str()]).unwrap(); |
| assert!( |
| String::from_utf8(summary) |
| .unwrap() |
| .contains("\"dat_version\":null") |
| ); |
| for format in ["dat-201501280", "dat-201512200"] { |
| let target = d.0.join(format); |
| call(&[ |
| "convert".as_ref(), |
| input.as_os_str(), |
| target.as_os_str(), |
| "--to".as_ref(), |
| format.as_ref(), |
| ]) |
| .unwrap(); |
| assert!(mb3_dat::decode(&fs::read(&target).unwrap(), &Limits::default()).is_ok()); |
| call(&["validate".as_ref(), target.as_os_str()]).unwrap(); |
| let txt = d.0.join(format!("{format}.txt")); |
| call(&[ |
| "convert".as_ref(), |
| target.as_os_str(), |
| txt.as_os_str(), |
| "--to".as_ref(), |
| "txt".as_ref(), |
| ]) |
| .unwrap(); |
| assert_eq!( |
| mb3_txt::decode(&fs::read(txt).unwrap(), &Limits::default()).unwrap(), |
| World::default() |
| ); |
| } |
| } |
| #[test] |
| fn usage_and_explicit_limits() { |
| for args in [ |
| vec![], |
| vec!["x"], |
| vec!["inspect"], |
| vec!["convert", "in", "out"], |
| vec!["inspect", "in", "--force"], |
| vec!["inspect", "in", "--max-items", "-1"], |
| vec!["inspect", "in", "--from", "txt", "--from", "dat"], |
| ] { |
| let args: Vec<_> = args.iter().map(std::ffi::OsStr::new).collect(); |
| assert!(call(&args).unwrap_err().usage); |
| } |
| assert!(!call(&["--help".as_ref()]).unwrap().is_empty()); |
| let d = Dir::new(); |
| let p = d.file("in", EMPTY); |
| assert!( |
| !call(&[ |
| "validate".as_ref(), |
| p.as_os_str(), |
| "--max-bytes".as_ref(), |
| "1".as_ref() |
| ]) |
| .unwrap_err() |
| .usage |
| ); |
| assert!( |
| call(&[ |
| "validate".as_ref(), |
| p.as_os_str(), |
| "--from".as_ref(), |
| "dat".as_ref() |
| ]) |
| .is_err() |
| ); |
| } |
| #[test] |
| fn no_clobber_force_and_same_file_protection() { |
| let d = Dir::new(); |
| let input = d.file("in", EMPTY); |
| let output = d.file("out", b"ORIGINAL"); |
| assert!(save(&input, &output, b"NEW", false).is_err()); |
| assert_eq!(fs::read(&output).unwrap(), b"ORIGINAL"); |
| save(&input, &output, b"NEW", true).unwrap(); |
| assert_eq!(fs::read(&output).unwrap(), b"NEW"); |
| assert!(save(&input, &input, b"BAD", true).is_err()); |
| let link = d.0.join("hardlink"); |
| fs::hard_link(&input, &link).unwrap(); |
| assert!(save(&input, &link, b"BAD", true).is_err()); |
| assert_eq!(fs::read(input).unwrap(), EMPTY); |
| assert_eq!(fs::read_dir(&d.0).unwrap().count(), 3); |
| } |
| #[test] |
| fn failed_validation_creates_no_output_or_temporary() { |
| let d = Dir::new(); |
| let input = d.file( |
| "in", |
| b"world(computedFeatures false stringProperties[\"p\"])", |
| ); |
| let output = d.0.join("out"); |
| assert!( |
| call(&[ |
| "convert".as_ref(), |
| input.as_os_str(), |
| output.as_os_str(), |
| "--to".as_ref(), |
| "dat-201501280".as_ref() |
| ]) |
| .is_err() |
| ); |
| assert!(!output.exists()); |
| assert_eq!(fs::read_dir(&d.0).unwrap().count(), 1); |
| } |
| #[cfg(unix)] |
| #[test] |
| fn symlink_destinations_rejected() { |
| let d = Dir::new(); |
| let input = d.file("in", EMPTY); |
| let target = d.file("target", b"ORIGINAL"); |
| let link = d.0.join("link"); |
| std::os::unix::fs::symlink(&target, &link).unwrap(); |
| assert!(save(&input, &link, b"BAD", true).is_err()); |
| assert_eq!(fs::read(target).unwrap(), b"ORIGINAL"); |
| } |
| #[test] |
| fn failed_publication_cleans_temporary_and_preserves_existing() { |
| let d = Dir::new(); |
| let input = d.file("in", EMPTY); |
| let output = d.0.join("out"); |
| fs::create_dir(&output).unwrap(); |
| assert!(save(&input, &output, b"NEW", false).is_err()); |
| assert_eq!(fs::read_dir(&d.0).unwrap().count(), 2); |
| } |
|
|
| #[test] |
| fn publication_race_is_no_clobber_and_owned_temp_is_cleaned() { |
| let d = Dir::new(); |
| let output = d.file("winner", b"EXISTING"); |
| let path = d.file("staged", b"REPLACEMENT"); |
| assert!(publish(Temp(path.clone()), &output, false).is_err()); |
| assert!(!path.exists()); |
| assert_eq!(fs::read(output).unwrap(), b"EXISTING"); |
| } |
| #[test] |
| fn invalid_conversion_with_force_keeps_existing_destination() { |
| let d = Dir::new(); |
| let input = d.file( |
| "unicode.txt", |
| "world(computedFeatures false stringProperties[\"é\"])".as_bytes(), |
| ); |
| let output = d.file("out.dat", b"KEEP"); |
| assert!( |
| call(&[ |
| "convert".as_ref(), |
| input.as_os_str(), |
| output.as_os_str(), |
| "--to".as_ref(), |
| "dat-201512200".as_ref(), |
| "--force".as_ref() |
| ]) |
| .is_err() |
| ); |
| assert_eq!(fs::read(output).unwrap(), b"KEEP"); |
| assert_eq!(fs::read_dir(&d.0).unwrap().count(), 2); |
| } |
|
|
