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
  47 fn verify_access_permissions(permission: &Permission) -> Result<(), Error> {
  48
  49     match permission {
  50         Permission::Or(list) => {
  51             for perm in list.iter() { verify_access_permissions(perm)?; }
  52         }
  53         Permission::And(list) => {
  54             for perm in list.iter() { verify_access_permissions(perm)?; }
  55         }
  56         Permission::Privilege(path_comp, ..)=> {
  57             let path = format!("/{}", path_comp.join("/"));
  58             proxmox_backup::config::acl::check_acl_path(&path)?;
  59         }
  60         _ => {}
  61     }
  62     Ok(())
  63 }
  64
  65 fn verify_api_method(
  66     method: &str,
  67     path: &str,
  68     info: &ApiMethod
  69 ) -> Result<(), Error>
  70 {
  71     verify_object_schema(info.parameters)
  72         .map_err(|err| format_err!("{} {} parameters: {}", method, path, err))?;
  73
  74     verify_schema(info.returns)
  75         .map_err(|err| format_err!("{} {} returns: {}", method, path, err))?;
  76
  77     verify_access_permissions(info.access.permission)
  78         .map_err(|err| format_err!("{} {} access: {}", method, path, err))?;
  79
  80     Ok(())
  81 }
  82
  83 fn verify_dirmap(
  84     path: &str,
  85     dirmap: SubdirMap,
  86 ) -> Result<(), Error> {
  87
  88     if dirmap.len() >= 1 {
  89
  90         for i in 1..dirmap.len() {
  91
  92             if dirmap[i].0 <= dirmap[i-1].0 {
  93                 for (name, _) in dirmap.iter() {
  94                     eprintln!("{}/{}", path, name);
  95                 }
  96                 bail!("found unsorted dirmap at {:?} ({} <= {})", path, dirmap[i].0, dirmap[i-1].0);
  97             }
  98
  99         }
 100     }
 101
 102     for (name, router) in dirmap.iter() {
 103         let sub_path = format!("{}/{}", path, name);
 104         verify_router(&sub_path, router)?;
 105     }
 106
 107     Ok(())
 108 }
 109
 110 fn verify_router(path: &str, router: &Router) -> Result<(), Error> {
 111
 112     println!("Verify {}", path);
 113
 114     if let Some(api_method) = router.get {
 115         verify_api_method("GET", path, api_method)?;
 116     }
 117     if let Some(api_method) = router.put {
 118         verify_api_method("PUT", path, api_method)?;
 119     }
 120     if let Some(api_method) = router.post {
 121         verify_api_method("POST", path, api_method)?;
 122     }
 123     if let Some(api_method) = router.delete {
 124         verify_api_method("DELETE", path, api_method)?;
 125     }
 126
 127     match router.subroute {
 128         Some(SubRoute::Map(dirmap)) => {
 129             verify_dirmap(path, dirmap)?;
 130         }
 131         Some(SubRoute::MatchAll { router, param_name }) => {
 132             let path = format!("{}/{{{}}}", path, param_name);
 133             verify_router(&path, router)?;
 134         }
 135         None => {}
 136     }
 137
 138     Ok(())
 139 }
 140
 141 #[test]
 142 fn verify_backup_api() -> Result<(), Error> {
 143
 144     let api = &api2::backup::BACKUP_API_ROUTER;
 145     verify_router("backup-api", api)?;
 146
 147     Ok(())
 148 }
 149
 150 #[test]
 151 fn verify_reader_api() -> Result<(), Error> {
 152
 153     let api = &api2::reader::READER_API_ROUTER;
 154     verify_router("reader-api", api)?;
 155
 156     Ok(())
 157 }
 158
 159 #[test]
 160 fn verify_root_api() -> Result<(), Error> {
 161
 162     let api = &api2::ROUTER;
 163     verify_router("root", api)?;
 164
 165     Ok(())
 166 }