src/tape/test/inventory.rs

   1 // Tape inventory tests
   2 //
   3 // # cargo test --release tape::test::inventory
   4
   5 use std::path::PathBuf;
   6 use anyhow::{bail, Error};
   7
   8 use proxmox::tools::{
   9     Uuid,
  10 };
  11
  12 use pbs_api_types::{MediaLocation, MediaStatus};
  13
  14 use crate::{
  15     tape::{
  16         Inventory,
  17         file_formats::{
  18             MediaSetLabel,
  19         },
  20     },
  21 };
  22
  23 fn create_testdir(name: &str) -> Result<PathBuf, Error> {
  24     let mut testdir: PathBuf = String::from("./target/testout").into();
  25     testdir.push(std::module_path!());
  26     testdir.push(name);
  27
  28     let _ = std::fs::remove_dir_all(&testdir);
  29     let _ = std::fs::create_dir_all(&testdir);
  30
  31     Ok(testdir)
  32 }
  33
  34 #[test]
  35 fn test_media_state_db() -> Result<(), Error> {
  36
  37     let testdir = create_testdir("test_media_state_db")?;
  38
  39     let mut inventory = Inventory::load(&testdir)?;
  40
  41     let uuid1: Uuid = inventory.generate_free_tape("tape1", 0);
  42
  43     assert_eq!(inventory.status_and_location(&uuid1), (MediaStatus::Unknown, MediaLocation::Offline));
  44
  45     inventory.set_media_status_full(&uuid1)?;
  46
  47     assert_eq!(inventory.status_and_location(&uuid1), (MediaStatus::Full, MediaLocation::Offline));
  48
  49     inventory.set_media_location_vault(&uuid1, "Office2")?;
  50     assert_eq!(inventory.status_and_location(&uuid1),
  51                (MediaStatus::Full, MediaLocation::Vault(String::from("Office2"))));
  52
  53     inventory.set_media_location_offline(&uuid1)?;
  54     assert_eq!(inventory.status_and_location(&uuid1), (MediaStatus::Full, MediaLocation::Offline));
  55
  56     inventory.set_media_status_damaged(&uuid1)?;
  57     assert_eq!(inventory.status_and_location(&uuid1), (MediaStatus::Damaged, MediaLocation::Offline));
  58
  59     inventory.clear_media_status(&uuid1)?;
  60     assert_eq!(inventory.status_and_location(&uuid1), (MediaStatus::Unknown, MediaLocation::Offline));
  61
  62     Ok(())
  63 }
  64
  65 #[test]
  66 fn test_list_pool_media() -> Result<(), Error> {
  67
  68     let testdir = create_testdir("test_list_pool_media")?;
  69     let mut inventory = Inventory::load(&testdir)?;
  70
  71     let ctime = 0;
  72
  73     let _tape1_uuid = inventory.generate_free_tape("tape1", ctime);
  74     let tape2_uuid = inventory.generate_assigned_tape("tape2", "p1", ctime);
  75
  76     let set1 = MediaSetLabel::with_data("p1", Uuid::generate(), 0, ctime, None);
  77
  78     let tape3_uuid = inventory.generate_used_tape("tape3", set1.clone(), ctime);
  79
  80     let list = inventory.list_pool_media("nonexistent_pool");
  81     assert_eq!(list.len(), 0);
  82
  83     let list = inventory.list_pool_media("p1");
  84     assert_eq!(list.len(), 2);
  85
  86     let tape2 = list.iter().find(|media_id| &media_id.label.uuid == &tape2_uuid).unwrap();
  87     assert!(tape2.media_set_label.is_none());
  88
  89     let tape3 = list.iter().find(|media_id| &media_id.label.uuid == &tape3_uuid).unwrap();
  90     match tape3.media_set_label {
  91         None => bail!("missing media set label"),
  92         Some(ref set) => {
  93             assert_eq!(set.seq_nr, 0);
  94             assert_eq!(set.uuid, set1.uuid);
  95         }
  96     }
  97     Ok(())
  98 }
  99
 100 #[test]
 101 fn test_media_set_simple() -> Result<(), Error> {
 102
 103     let testdir = create_testdir("test_media_set_simple")?;
 104     let mut inventory = Inventory::load(&testdir)?;
 105
 106     let ctime = 0;
 107
 108     let sl1 = MediaSetLabel::with_data("p1", Uuid::generate(), 0, ctime + 10, None);
 109     let sl2 = MediaSetLabel::with_data("p1", sl1.uuid.clone(), 1, ctime+ 20, None);
 110     let sl3 = MediaSetLabel::with_data("p1", sl1.uuid.clone(), 2, ctime + 30, None);
 111
 112
 113     let tape1_uuid = inventory.generate_used_tape("tape1", sl1.clone(), 0);
 114     let tape2_uuid = inventory.generate_used_tape("tape2", sl2.clone(), 0);
 115     let tape3_uuid = inventory.generate_used_tape("tape3", sl3.clone(), 0);
 116
 117     // generate incomplete media set in pool p2
 118     let sl4 = MediaSetLabel::with_data("p2", Uuid::generate(), 1, ctime + 40, None);
 119     let tape4_uuid = inventory.generate_used_tape("tape4", sl4.clone(), 0);
 120
 121     let media_list = inventory.list_pool_media("p1");
 122     assert_eq!(media_list.len(), 3);
 123
 124     let media_list = inventory.list_pool_media("p2");
 125     assert_eq!(media_list.len(), 1);
 126
 127     // reload, the do more tests
 128
 129     let inventory = Inventory::load(&testdir)?;
 130
 131     // test pool p1
 132
 133     let media_set = inventory.compute_media_set_members(&sl1.uuid)?;
 134     assert_eq!(media_set.uuid(), &sl1.uuid);
 135
 136     let media_list = media_set.media_list();
 137     assert_eq!(media_list.len(), 3);
 138
 139     assert_eq!(media_list[0], Some(tape1_uuid.clone()));
 140     assert_eq!(media_list[1], Some(tape2_uuid.clone()));
 141     assert_eq!(media_list[2], Some(tape3_uuid.clone()));
 142
 143     // test media set start time
 144     assert_eq!(inventory.media_set_start_time(&sl1.uuid), Some(ctime + 10));
 145
 146
 147     // test pool p2
 148     let media_set = inventory.compute_media_set_members(&sl4.uuid)?;
 149     assert_eq!(media_set.uuid(), &sl4.uuid);
 150
 151     let media_list = media_set.media_list();
 152     assert_eq!(media_list.len(), 2);
 153
 154     assert_eq!(media_list[0], None);
 155     assert_eq!(media_list[1], Some(tape4_uuid.clone()));
 156
 157     // start time for incomplete set must be None
 158     assert_eq!(inventory.media_set_start_time(&sl4.uuid), None);
 159
 160     Ok(())
 161 }
 162
 163
 164 #[test]
 165 fn test_latest_media_set() -> Result<(), Error> {
 166
 167     let testdir = create_testdir("test_latest_media_set")?;
 168
 169     let insert_tape = |inventory: &mut Inventory, pool, label, seq_nr, ctime| -> Uuid {
 170         let sl = MediaSetLabel::with_data(pool, Uuid::generate(), seq_nr, ctime, None);
 171         let uuid = sl.uuid.clone();
 172         inventory.generate_used_tape(label, sl, 0);
 173         uuid
 174     };
 175
 176     let check_latest = |inventory: &Inventory, pool: &str, label: &str| {
 177         let latest_set = inventory.latest_media_set(pool).unwrap();
 178         let set = inventory.compute_media_set_members(&latest_set).unwrap();
 179         let media_list = set.media_list();
 180         assert_eq!(media_list.iter().filter(|s| s.is_some()).count(), 1);
 181         let media_uuid = media_list.iter().find(|s| s.is_some()).unwrap().clone().unwrap();
 182         let media = inventory.lookup_media(&media_uuid).unwrap();
 183         assert_eq!(media.label.label_text, label);
 184     };
 185
 186     let mut inventory = Inventory::load(&testdir)?;
 187
 188     let ctime = 0;
 189
 190     // test 3 sets with different start times
 191
 192     insert_tape(&mut inventory, "p1", "p1tape1", 0, ctime + 10);
 193     insert_tape(&mut inventory, "p1", "p1tape2", 0, ctime + 20);
 194     insert_tape(&mut inventory, "p1", "p1tape3", 0, ctime + 30);
 195
 196     check_latest(&inventory, "p1", "p1tape3");
 197
 198     // test 2 sets with same start times, should fail
 199
 200     insert_tape(&mut inventory, "p2", "p2tape1", 0, ctime + 10);
 201     insert_tape(&mut inventory, "p2", "p2tape2", 0, ctime + 10);
 202
 203     assert_eq!(inventory.latest_media_set("p2"), None);
 204
 205     // test with incomplete sets
 206
 207     insert_tape(&mut inventory, "p3", "p3tape1", 5, ctime + 50);
 208     insert_tape(&mut inventory, "p3", "p3tape2", 1, ctime + 10);
 209     insert_tape(&mut inventory, "p3", "p3tape3", 0, ctime + 20);
 210
 211     check_latest(&inventory, "p3", "p3tape1");
 212
 213     Ok(())
 214 }