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
  26 fn verify_test_blob(mut cursor: Cursor<Vec<u8>>) -> Result<(), Error> {
  27
  28     // run read tests with different buffer sizes
  29     for size in [1, 3, 64*1024].iter() {
  30
  31         println!("Starting DataBlobReader test (size = {})", size);
  32
  33         cursor.seek(SeekFrom::Start(0))?;
  34         let mut reader = DataBlobReader::new(&mut cursor, Some(CRYPT_CONFIG.clone()))?;
  35         let mut buffer = Vec::<u8>::new();
  36         // read the whole file
  37         //reader.read_to_end(&mut buffer)?;
  38         let mut buf = vec![0u8; *size];
  39         loop {
  40             let count = reader.read(&mut buf)?;
  41             if count == 0 { break; }
  42             buffer.extend(&buf[..count]);
  43         }
  44
  45         reader.finish()?;
  46         if buffer != *TEST_DATA {
  47             bail!("blob data is wrong (read buffer size {})", size);
  48         }
  49     }
  50
  51     let raw_data = cursor.into_inner();
  52
  53     let blob = DataBlob::from_raw(raw_data)?;
  54     blob.verify_crc()?;
  55
  56     let data = blob.decode(Some(&CRYPT_CONFIG))?;
  57     if data != *TEST_DATA {
  58         bail!("blob data is wrong (decode)");
  59     }
  60     Ok(())
  61 }
  62
  63 #[test]
  64 fn test_uncompressed_blob_writer() -> Result<(), Error> {
  65     let tmp = Cursor::new(Vec::<u8>::new());
  66     let mut blob_writer = DataBlobWriter::new_uncompressed(tmp)?;
  67     blob_writer.write_all(&TEST_DATA)?;
  68
  69     verify_test_blob(blob_writer.finish()?)
  70 }
  71
  72 #[test]
  73 fn test_compressed_blob_writer() -> Result<(), Error> {
  74     let tmp = Cursor::new(Vec::<u8>::new());
  75     let mut blob_writer = DataBlobWriter::new_compressed(tmp)?;
  76     blob_writer.write_all(&TEST_DATA)?;
  77
  78     verify_test_blob(blob_writer.finish()?)
  79 }
  80
  81 #[test]
  82 fn test_signed_blob_writer() -> Result<(), Error> {
  83     let tmp = Cursor::new(Vec::<u8>::new());
  84     let mut blob_writer = DataBlobWriter::new_signed(tmp, CRYPT_CONFIG.clone())?;
  85     blob_writer.write_all(&TEST_DATA)?;
  86
  87     verify_test_blob(blob_writer.finish()?)
  88 }
  89
  90 #[test]
  91 fn test_signed_compressed_blob_writer() -> Result<(), Error> {
  92     let tmp = Cursor::new(Vec::<u8>::new());
  93     let mut blob_writer = DataBlobWriter::new_signed_compressed(tmp, CRYPT_CONFIG.clone())?;
  94     blob_writer.write_all(&TEST_DATA)?;
  95
  96     verify_test_blob(blob_writer.finish()?)
  97 }
  98
  99 #[test]
 100 fn test_encrypted_blob_writer() -> Result<(), Error> {
 101     let tmp = Cursor::new(Vec::<u8>::new());
 102     let mut blob_writer = DataBlobWriter::new_encrypted(tmp, CRYPT_CONFIG.clone())?;
 103     blob_writer.write_all(&TEST_DATA)?;
 104
 105     verify_test_blob(blob_writer.finish()?)
 106 }
 107
 108 #[test]
 109 fn test_encrypted_compressed_blob_writer() -> Result<(), Error> {
 110     let tmp = Cursor::new(Vec::<u8>::new());
 111     let mut blob_writer = DataBlobWriter::new_encrypted_compressed(tmp, CRYPT_CONFIG.clone())?;
 112     blob_writer.write_all(&TEST_DATA)?;
 113
 114     verify_test_blob(blob_writer.finish()?)
 115 }