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