tests/blob_writer.rs

   1 use anyhow::{bail, Error};
   2 use std::sync::Arc;
   3 use std::io::Cursor;
   4 use std::io::{Read, Write, Seek, SeekFrom };
   5 use lazy_static::lazy_static;
   6
   7 use proxmox_backup::backup::*;
   8
   9 lazy_static! {
  10     static ref TEST_DATA: Vec<u8> = {
  11         let mut data = Vec::new();
  12
  13         for i in 0..100_000 {
  14             data.push((i%255) as u8);
  15         }
  16
  17         data
  18     };
  19
  20     static ref CRYPT_CONFIG: Arc<CryptConfig> = {
  21         let key = [1u8; 32];
  22         Arc::new(CryptConfig::new(key).unwrap())
  23     };
  24
  25     static ref TEST_DIGEST_PLAIN: [u8; 32] = [83, 154, 96, 195, 167, 204, 38, 142, 204, 224, 130, 201, 24, 71, 2, 188, 130, 155, 177, 6, 162, 100, 61, 238, 38, 219, 63, 240, 191, 132, 87, 238];
  26
  27     static ref TEST_DIGEST_ENC: [u8; 32] = [50, 162, 191, 93, 255, 132, 9, 14, 127, 23, 92, 39, 246, 102, 245, 204, 130, 104, 4, 106, 182, 239, 218, 14, 80, 17, 150, 188, 239, 253, 198, 117];
  28 }
  29
  30 fn verify_test_blob(mut cursor: Cursor<Vec<u8>>, digest: &[u8; 32]) -> Result<(), Error> {
  31
  32     // run read tests with different buffer sizes
  33     for size in [1, 3, 64*1024].iter() {
  34
  35         println!("Starting DataBlobReader test (size = {})", size);
  36
  37         cursor.seek(SeekFrom::Start(0))?;
  38         let mut reader = DataBlobReader::new(&mut cursor, Some(CRYPT_CONFIG.clone()))?;
  39         let mut buffer = Vec::<u8>::new();
  40         // read the whole file
  41         //reader.read_to_end(&mut buffer)?;
  42         let mut buf = vec![0u8; *size];
  43         loop {
  44             let count = reader.read(&mut buf)?;
  45             if count == 0 { break; }
  46             buffer.extend(&buf[..count]);
  47         }
  48
  49         reader.finish()?;
  50         if buffer != *TEST_DATA {
  51             bail!("blob data is wrong (read buffer size {})", size);
  52         }
  53     }
  54
  55     let raw_data = cursor.into_inner();
  56
  57     let blob = DataBlob::load_from_reader(&mut &raw_data[..])?;
  58
  59     let data = blob.decode(Some(&CRYPT_CONFIG), Some(digest))?;
  60     if data != *TEST_DATA {
  61         bail!("blob data is wrong (decode)");
  62     }
  63     Ok(())
  64 }
  65
  66 #[test]
  67 fn test_uncompressed_blob_writer() -> Result<(), Error> {
  68     let tmp = Cursor::new(Vec::<u8>::new());
  69     let mut blob_writer = DataBlobWriter::new_uncompressed(tmp)?;
  70     blob_writer.write_all(&TEST_DATA)?;
  71
  72     verify_test_blob(blob_writer.finish()?, &*TEST_DIGEST_PLAIN)
  73 }
  74
  75 #[test]
  76 fn test_compressed_blob_writer() -> Result<(), Error> {
  77     let tmp = Cursor::new(Vec::<u8>::new());
  78     let mut blob_writer = DataBlobWriter::new_compressed(tmp)?;
  79     blob_writer.write_all(&TEST_DATA)?;
  80
  81     verify_test_blob(blob_writer.finish()?, &*TEST_DIGEST_PLAIN)
  82 }
  83
  84 #[test]
  85 fn test_encrypted_blob_writer() -> Result<(), Error> {
  86     let tmp = Cursor::new(Vec::<u8>::new());
  87     let mut blob_writer = DataBlobWriter::new_encrypted(tmp, CRYPT_CONFIG.clone())?;
  88     blob_writer.write_all(&TEST_DATA)?;
  89
  90     verify_test_blob(blob_writer.finish()?, &*TEST_DIGEST_ENC)
  91 }
  92
  93 #[test]
  94 fn test_encrypted_compressed_blob_writer() -> Result<(), Error> {
  95     let tmp = Cursor::new(Vec::<u8>::new());
  96     let mut blob_writer = DataBlobWriter::new_encrypted_compressed(tmp, CRYPT_CONFIG.clone())?;
  97     blob_writer.write_all(&TEST_DATA)?;
  98
  99     verify_test_blob(blob_writer.finish()?, &*TEST_DIGEST_ENC)
 100 }