lib

Core libraries for Radroots
git clone https://radroots.dev/git/lib.git
Log | Files | Refs | README

conformance_inventory_tests.rs (6038B)


      1 use super::validate_all_conformance_vectors;
      2 use std::{fs, path::Path};
      3 
      4 const VECTOR: &str = r#"{"suite":"inventory-control","contract_version":"1.0.0","vectors":[{"id":"inventory-control-001","kind":"synthetic.operation","input":{},"expected":{}}]}"#;
      5 
      6 fn vectors_root(root: &Path) -> std::path::PathBuf {
      7     root.join("contracts/conformance/vectors")
      8 }
      9 
     10 fn fixture() -> tempfile::TempDir {
     11     let root = tempfile::tempdir().expect("disposable inventory root");
     12     fs::create_dir_all(vectors_root(root.path())).expect("fixed vector scaffold");
     13     root
     14 }
     15 
     16 fn write_vector(path: &Path) {
     17     fs::write(path, VECTOR).expect("synthetic vector");
     18 }
     19 
     20 #[test]
     21 fn valid_nested_regular_vectors_and_ignored_files_validate() {
     22     let root = fixture();
     23     let vectors = vectors_root(root.path());
     24     fs::create_dir(vectors.join("a")).expect("first vector directory");
     25     fs::create_dir(vectors.join("z")).expect("last vector directory");
     26     write_vector(&vectors.join("a/first.json"));
     27     write_vector(&vectors.join("middle.json"));
     28     write_vector(&vectors.join("z/last.json"));
     29     fs::write(vectors.join("README.txt"), "ordinary ignored file").expect("ignored file");
     30 
     31     validate_all_conformance_vectors(root.path(), "1.0.0").expect("valid nested inventory");
     32 
     33     assert_eq!(
     34         fs::read_to_string(vectors.join("middle.json")).unwrap(),
     35         VECTOR
     36     );
     37 }
     38 
     39 #[test]
     40 fn lexical_depth_first_error_order_is_preserved() {
     41     let root = fixture();
     42     let vectors = vectors_root(root.path());
     43     fs::create_dir(vectors.join("a")).expect("first vector directory");
     44     for relative in ["z.json", "b.json", "a/first.json"] {
     45         fs::write(
     46             vectors.join(relative),
     47             VECTOR.replace("inventory-control", ""),
     48         )
     49         .expect("invalid synthetic vector");
     50     }
     51 
     52     let error = validate_all_conformance_vectors(root.path(), "1.0.0")
     53         .expect_err("invalid inventory must fail");
     54     assert!(error.contains("a/first.json"), "{error}");
     55     assert!(error.contains("suite must not be empty"), "{error}");
     56 }
     57 
     58 #[cfg(unix)]
     59 fn assert_link_rejected(root: &Path, link: &Path) {
     60     let error = validate_all_conformance_vectors(root, "1.0.0")
     61         .expect_err("linked conformance inventory must be rejected");
     62     assert!(error.contains("symlink"), "{error}");
     63     assert!(fs::symlink_metadata(link).unwrap().file_type().is_symlink());
     64 }
     65 
     66 #[cfg(unix)]
     67 #[test]
     68 fn linked_vector_file_is_rejected_without_changing_its_target() {
     69     let root = fixture();
     70     let foreign = root.path().join("foreign.json");
     71     write_vector(&foreign);
     72     let link = vectors_root(root.path()).join("linked.json");
     73     std::os::unix::fs::symlink(&foreign, &link).expect("fixture file link");
     74 
     75     assert_link_rejected(root.path(), &link);
     76     assert_eq!(fs::read_to_string(&foreign).unwrap(), VECTOR);
     77     assert!(fs::symlink_metadata(&foreign).unwrap().is_file());
     78 }
     79 
     80 #[cfg(unix)]
     81 #[test]
     82 fn linked_vector_directory_is_rejected_without_entering_its_target() {
     83     let root = fixture();
     84     let foreign = root.path().join("foreign");
     85     fs::create_dir(&foreign).expect("foreign fixture directory");
     86     write_vector(&foreign.join("vector.json"));
     87     let link = vectors_root(root.path()).join("linked");
     88     std::os::unix::fs::symlink(&foreign, &link).expect("fixture directory link");
     89 
     90     assert_link_rejected(root.path(), &link);
     91     assert_eq!(
     92         fs::read_to_string(foreign.join("vector.json")).unwrap(),
     93         VECTOR
     94     );
     95     assert!(fs::symlink_metadata(&foreign).unwrap().is_dir());
     96 }
     97 
     98 #[cfg(unix)]
     99 #[test]
    100 fn linked_inventory_root_is_rejected_without_changing_its_target() {
    101     let root = fixture();
    102     let foreign = root.path().join("foreign");
    103     fs::create_dir(&foreign).expect("foreign fixture directory");
    104     write_vector(&foreign.join("vector.json"));
    105     let link = vectors_root(root.path());
    106     fs::remove_dir(&link).expect("empty fixture vector directory");
    107     std::os::unix::fs::symlink(&foreign, &link).expect("fixture root link");
    108 
    109     assert_link_rejected(root.path(), &link);
    110     assert_eq!(
    111         fs::read_to_string(foreign.join("vector.json")).unwrap(),
    112         VECTOR
    113     );
    114 }
    115 
    116 #[cfg(unix)]
    117 #[test]
    118 fn linked_inventory_parent_is_rejected_without_changing_its_target() {
    119     let root = fixture();
    120     write_vector(&vectors_root(root.path()).join("vector.json"));
    121     let link = root.path().join("contracts");
    122     let foreign = root.path().join("foreign");
    123     fs::rename(&link, &foreign).expect("move owned fixture scaffold");
    124     std::os::unix::fs::symlink(&foreign, &link).expect("fixture parent link");
    125 
    126     assert_link_rejected(root.path(), &link);
    127     assert_eq!(
    128         fs::read_to_string(foreign.join("conformance/vectors/vector.json")).unwrap(),
    129         VECTOR
    130     );
    131 }
    132 
    133 #[cfg(unix)]
    134 #[test]
    135 fn dangling_ignored_suffix_link_is_rejected_without_repairing_it() {
    136     let root = fixture();
    137     write_vector(&vectors_root(root.path()).join("vector.json"));
    138     let missing = root.path().join("absent");
    139     let link = vectors_root(root.path()).join("ignored.txt");
    140     std::os::unix::fs::symlink(&missing, &link).expect("dangling fixture link");
    141 
    142     assert_link_rejected(root.path(), &link);
    143     assert!(!missing.exists());
    144     assert_eq!(fs::read_link(&link).unwrap(), missing);
    145 }
    146 
    147 #[cfg(unix)]
    148 #[test]
    149 fn nonregular_vector_is_rejected_before_reading_it() {
    150     let root = fixture();
    151     let socket = vectors_root(root.path()).join("socket.json");
    152     let short_socket = root.path().join("s");
    153     let _listener =
    154         std::os::unix::net::UnixListener::bind(&short_socket).expect("disposable socket fixture");
    155     fs::rename(&short_socket, &socket).expect("move owned socket into vector inventory");
    156 
    157     let error = validate_all_conformance_vectors(root.path(), "1.0.0")
    158         .expect_err("nonregular vector must fail admission");
    159     assert!(error.contains("regular file"), "{error}");
    160     use std::os::unix::fs::FileTypeExt;
    161     assert!(
    162         fs::symlink_metadata(&socket)
    163             .unwrap()
    164             .file_type()
    165             .is_socket()
    166     );
    167 }