tests/blob_writer.rs

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