tests/blob_writer.rs

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