src/tape/test/current_set_usable.rs

   1 // Tape Media Pool tests - test current_set_usable() function
   2 //
   3 // # cargo test --release tape::test::current_set_usable
   4
   5 use std::path::PathBuf;
   6 use anyhow::Error;
   7
   8 use proxmox_uuid::Uuid;
   9
  10 use pbs_api_types::{RetentionPolicy, MediaSetPolicy};
  11
  12 use crate::{
  13     tape::{
  14         Inventory,
  15         MediaPool,
  16         file_formats::{
  17             MediaSetLabel,
  18         },
  19     },
  20 };
  21
  22 fn create_testdir(name: &str) -> Result<PathBuf, Error> {
  23     let mut testdir: PathBuf = String::from("./target/testout").into();
  24     testdir.push(std::module_path!());
  25     testdir.push(name);
  26
  27     let _ = std::fs::remove_dir_all(&testdir);
  28     let _ = std::fs::create_dir_all(&testdir);
  29
  30     Ok(testdir)
  31 }
  32
  33 #[test]
  34 fn test_current_set_usable_1() -> Result<(), Error> {
  35
  36     let testdir = create_testdir("test_current_set_usable_1")?;
  37
  38     // pool without any media
  39
  40     let pool = MediaPool::new(
  41         "p1",
  42         &testdir,
  43         MediaSetPolicy::AlwaysCreate,
  44         RetentionPolicy::KeepForever,
  45         None,
  46         None,
  47         false,
  48     )?;
  49
  50     assert_eq!(pool.current_set_usable()?, false);
  51
  52     Ok(())
  53 }
  54
  55 #[test]
  56 fn test_current_set_usable_2() -> Result<(), Error> {
  57
  58     let testdir = create_testdir("test_current_set_usable_2")?;
  59
  60     let ctime = 0;
  61
  62     let mut inventory = Inventory::load(&testdir)?;
  63
  64     inventory.generate_assigned_tape("tape1", "p1", ctime);
  65
  66     // pool with one free media
  67     let pool = MediaPool::new(
  68         "p1",
  69         &testdir,
  70         MediaSetPolicy::AlwaysCreate,
  71         RetentionPolicy::KeepForever,
  72         None,
  73         None,
  74         false,
  75     )?;
  76
  77     assert_eq!(pool.current_set_usable()?, false);
  78
  79     Ok(())
  80 }
  81
  82 #[test]
  83 fn test_current_set_usable_3() -> Result<(), Error> {
  84
  85     let testdir = create_testdir("test_current_set_usable_3")?;
  86
  87     let ctime = 0;
  88
  89     let mut inventory = Inventory::load(&testdir)?;
  90
  91     let sl1 = MediaSetLabel::with_data("p1", Uuid::generate(), 0, ctime, None);
  92
  93     inventory.generate_used_tape("tape1", sl1, ctime); // Note: Tape is offline
  94
  95     // pool with one media in current set, only use online media
  96     let pool = MediaPool::new(
  97         "p1",
  98         &testdir,
  99         MediaSetPolicy::AlwaysCreate,
 100         RetentionPolicy::KeepForever,
 101         Some(String::from("changer1")),
 102         None,
 103         false,
 104     )?;
 105
 106     assert_eq!(pool.current_set_usable()?, false);
 107
 108     Ok(())
 109 }
 110
 111 #[test]
 112 fn test_current_set_usable_4() -> Result<(), Error> {
 113
 114     let testdir = create_testdir("test_current_set_usable_4")?;
 115
 116     let ctime = 0;
 117
 118     let mut inventory = Inventory::load(&testdir)?;
 119
 120     let sl1 = MediaSetLabel::with_data("p1", Uuid::generate(), 0, ctime, None);
 121
 122     inventory.generate_used_tape("tape1", sl1, ctime); // Note: Tape is offline
 123
 124     // pool with one media in current set, use offline media
 125     let pool = MediaPool::new(
 126         "p1",
 127         &testdir,
 128         MediaSetPolicy::AlwaysCreate,
 129         RetentionPolicy::KeepForever,
 130         None,
 131         None,
 132         false,
 133     )?;
 134
 135     assert_eq!(pool.current_set_usable()?, true);
 136
 137     Ok(())
 138 }
 139
 140 #[test]
 141 fn test_current_set_usable_5() -> Result<(), Error> {
 142
 143     let testdir = create_testdir("test_current_set_usable_5")?;
 144
 145     let ctime = 0;
 146
 147     let mut inventory = Inventory::load(&testdir)?;
 148
 149     let sl1 = MediaSetLabel::with_data("p1", Uuid::generate(), 0, ctime, None);
 150     let sl2 = MediaSetLabel::with_data("p1", sl1.uuid.clone(), 1, ctime + 1, None);
 151
 152     inventory.generate_used_tape("tape1", sl1, ctime);
 153     inventory.generate_used_tape("tape2", sl2, ctime);
 154
 155     // pool with two media in current set
 156     let pool = MediaPool::new(
 157         "p1",
 158         &testdir,
 159         MediaSetPolicy::AlwaysCreate,
 160         RetentionPolicy::KeepForever,
 161         None,
 162         None,
 163         false,
 164     )?;
 165
 166     assert_eq!(pool.current_set_usable()?, true);
 167
 168     Ok(())
 169 }
 170
 171 #[test]
 172 fn test_current_set_usable_6() -> Result<(), Error> {
 173
 174     let testdir = create_testdir("test_current_set_usable_6")?;
 175
 176     let ctime = 0;
 177
 178     let mut inventory = Inventory::load(&testdir)?;
 179
 180     let sl2 = MediaSetLabel::with_data("p1", Uuid::generate(), 1, ctime + 1, None);
 181
 182     inventory.generate_used_tape("tape2", sl2, ctime);
 183
 184     // pool with incomplete current set
 185     let pool = MediaPool::new(
 186         "p1",
 187         &testdir,
 188         MediaSetPolicy::AlwaysCreate,
 189         RetentionPolicy::KeepForever,
 190         None,
 191         None,
 192         false,
 193     )?;
 194
 195     assert!(pool.current_set_usable().is_err());
 196
 197     Ok(())
 198 }
 199
 200 #[test]
 201 fn test_current_set_usable_7() -> Result<(), Error> {
 202
 203     let testdir = create_testdir("test_current_set_usable_7")?;
 204
 205     let ctime = 0;
 206
 207     let mut inventory = Inventory::load(&testdir)?;
 208
 209     let sl1 = MediaSetLabel::with_data("p1", Uuid::generate(), 0, ctime, None);
 210     let sl2 = MediaSetLabel::with_data("p1", sl1.uuid.clone(), 1, ctime + 1, None);
 211
 212     // generate damaged tape
 213     let tape1_uuid = inventory.generate_used_tape("tape1", sl1, ctime);
 214     inventory.set_media_status_damaged(&tape1_uuid)?;
 215
 216     inventory.generate_used_tape("tape2", sl2, ctime);
 217
 218
 219     // pool with one two media in current set, one set to damaged
 220     let pool = MediaPool::new(
 221         "p1",
 222         &testdir,
 223         MediaSetPolicy::AlwaysCreate,
 224         RetentionPolicy::KeepForever,
 225         None,
 226         None,
 227         false,
 228     )?;
 229
 230     assert!(pool.current_set_usable().is_err());
 231
 232     Ok(())
 233 }