tests/verify-api.rs

   1 use anyhow::{bail, format_err, Error};
   2
   3 use proxmox_backup::api2;
   4 use proxmox::api::*;
   5 use proxmox::api::schema::*;
   6
   7 // Simply test if api lookup tables inside Routers and Schemas are
   8 // correctly sorted.
   9
  10 fn verify_object_schema(schema: &ObjectSchema) -> Result<(), Error> {
  11
  12     let map = schema.properties;
  13
  14     if map.len() >= 1 {
  15
  16         for i in 1..map.len() {
  17
  18             if map[i].0 <= map[i-1].0 {
  19                 for (name, _, _) in map.iter() {
  20                     eprintln!("{}", name);
  21                 }
  22                 bail!("found unsorted property map ({} <= {})", map[i].0, map[i-1].0);
  23             }
  24         }
  25     }
  26
  27     for (_name, _, sub_schema) in map.iter() {
  28         verify_schema(sub_schema)?;
  29     }
  30
  31     Ok(())
  32 }
  33
  34 fn verify_schema(schema: &Schema) -> Result<(), Error> {
  35     match schema {
  36         Schema::Object(obj_schema) => {
  37             verify_object_schema(obj_schema)?;
  38         }
  39         Schema::Array(arr_schema) => {
  40             verify_schema(arr_schema.items)?;
  41         }
  42         _ => {}
  43     }
  44     Ok(())
  45 }
  46 fn verify_api_method(
  47     method: &str,
  48     path: &str,
  49     info: &ApiMethod
  50 ) -> Result<(), Error>
  51 {
  52     verify_object_schema(info.parameters)
  53         .map_err(|err| format_err!("{} {} parameters: {}", method, path, err))?;
  54
  55     verify_schema(info.returns)
  56         .map_err(|err| format_err!("{} {} returns: {}", method, path, err))?;
  57
  58     Ok(())
  59 }
  60
  61 fn verify_dirmap(
  62     path: &str,
  63     dirmap: SubdirMap,
  64 ) -> Result<(), Error> {
  65
  66     if dirmap.len() >= 1 {
  67
  68         for i in 1..dirmap.len() {
  69
  70             if dirmap[i].0 <= dirmap[i-1].0 {
  71                 for (name, _) in dirmap.iter() {
  72                     eprintln!("{}/{}", path, name);
  73                 }
  74                 bail!("found unsorted dirmap at {:?} ({} <= {})", path, dirmap[i].0, dirmap[i-1].0);
  75             }
  76
  77         }
  78     }
  79
  80     for (name, router) in dirmap.iter() {
  81         let sub_path = format!("{}/{}", path, name);
  82         verify_router(&sub_path, router)?;
  83     }
  84
  85     Ok(())
  86 }
  87
  88 fn verify_router(path: &str, router: &Router) -> Result<(), Error> {
  89
  90     println!("Verify {}", path);
  91
  92     if let Some(api_method) = router.get {
  93         verify_api_method("GET", path, api_method)?;
  94     }
  95     if let Some(api_method) = router.put {
  96         verify_api_method("PUT", path, api_method)?;
  97     }
  98     if let Some(api_method) = router.post {
  99         verify_api_method("POST", path, api_method)?;
 100     }
 101     if let Some(api_method) = router.delete {
 102         verify_api_method("DELETE", path, api_method)?;
 103     }
 104
 105     match router.subroute {
 106         Some(SubRoute::Map(dirmap)) => {
 107             verify_dirmap(path, dirmap)?;
 108         }
 109         Some(SubRoute::MatchAll { router, param_name }) => {
 110             let path = format!("{}/{{{}}}", path, param_name);
 111             verify_router(&path, router)?;
 112         }
 113         None => {}
 114     }
 115
 116     Ok(())
 117 }
 118
 119 #[test]
 120 fn verify_backup_api() -> Result<(), Error> {
 121
 122     let api = &api2::backup::BACKUP_API_ROUTER;
 123     verify_router("backup-api", api)?;
 124
 125     Ok(())
 126 }
 127
 128 #[test]
 129 fn verify_reader_api() -> Result<(), Error> {
 130
 131     let api = &api2::reader::READER_API_ROUTER;
 132     verify_router("reader-api", api)?;
 133
 134     Ok(())
 135 }
 136
 137 #[test]
 138 fn verify_root_api() -> Result<(), Error> {
 139
 140     let api = &api2::ROUTER;
 141     verify_router("root", api)?;
 142
 143     Ok(())
 144 }
 145
 146 #[test]
 147 fn verify_acl_role_schema() -> Result<(), Error> {
 148
 149     let list = match api2::types::ACL_ROLE_SCHEMA {
 150         Schema::String(StringSchema { format: Some(ApiStringFormat::Enum(list)), .. }) => list,
 151         _ => unreachable!(),
 152     };
 153
 154     let map = &proxmox_backup::config::acl::ROLE_NAMES;
 155     for item in *list {
 156         if !map.contains_key(item) {
 157             bail!("found role '{}' without description/mapping", item);
 158         }
 159     }
 160
 161     for role in map.keys() {
 162         if !list.contains(role) {
 163             bail!("role '{}' missing in ACL_ROLE_SCHEMA enum", role);
 164         }
 165     }
 166
 167     Ok(())
 168 }