emo/thin-provisioning-tools
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[functional-tests (rust)] factor out TestDir

Browse Source
This commit is contained in:
Joe Thornber 2020-07-31 14:26:22 +01:00
parent 084a26bf85
commit 78db9a24fa
4 changed files with 64 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

46
tests/common/mod.rs
View File

@ -12,13 +12,6 @@ use crate::common::xml_generator::{write_xml, FragmentedS, SingleThinS};
//------------------------------------------ //------------------------------------------
pub fn mk_path(dir: &Path, file: &str) -> PathBuf {
let mut p = PathBuf::new();
p.push(dir);
p.push(PathBuf::from(file));
p
}
// FIXME: write a macro to generate these commands // FIXME: write a macro to generate these commands
#[macro_export] #[macro_export]
macro_rules! thin_check { macro_rules! thin_check {
@ -53,6 +46,27 @@ macro_rules! thin_dump {
}; };
} }
//------------------------------------------
pub struct TestDir {
dir: TempDir,
file_count: usize,
}
impl TestDir {
pub fn new() -> Result<TestDir> {
let dir = tempdir()?;
Ok(TestDir {dir, file_count: 0})
}
pub fn mk_path(&mut self, file: &str) -> PathBuf {
let mut p = PathBuf::new();
p.push(&self.dir);
p.push(PathBuf::from(format!("{:02}_{}", self.file_count, file)));
self.file_count += 1;
p
}
}
// Returns stderr, a non zero status must be returned // Returns stderr, a non zero status must be returned
pub fn run_fail(command: Expression) -> Result<String> { pub fn run_fail(command: Expression) -> Result<String> {
@ -61,16 +75,16 @@ pub fn run_fail(command: Expression) -> Result<String> {
Ok(from_utf8(&output.stderr[0..]).unwrap().to_string()) Ok(from_utf8(&output.stderr[0..]).unwrap().to_string())
} }
pub fn mk_valid_xml(dir: &TempDir) -> Result<PathBuf> { pub fn mk_valid_xml(td: &mut TestDir) -> Result<PathBuf> {
let xml = mk_path(dir.path(), "meta.xml"); let xml = td.mk_path("meta.xml");
let mut gen = SingleThinS::new(0, 1024, 2048, 2048); let mut gen = SingleThinS::new(0, 1024, 2048, 2048);
write_xml(&xml, &mut gen)?; write_xml(&xml, &mut gen)?;
Ok(xml) Ok(xml)
} }
pub fn mk_valid_md(dir: &TempDir) -> Result<PathBuf> { pub fn mk_valid_md(td: &mut TestDir) -> Result<PathBuf> {
let xml = mk_path(dir.path(), "meta.xml"); let xml = td.mk_path("meta.xml");
let md = mk_path(dir.path(), "meta.bin"); let md = td.mk_path("meta.bin");
let mut gen = SingleThinS::new(0, 1024, 2048, 2048); let mut gen = SingleThinS::new(0, 1024, 2048, 2048);
write_xml(&xml, &mut gen)?; write_xml(&xml, &mut gen)?;
@ -80,15 +94,15 @@ pub fn mk_valid_md(dir: &TempDir) -> Result<PathBuf> {
Ok(md) Ok(md)
} }
pub fn mk_zeroed_md(dir: &TempDir) -> Result<PathBuf> { pub fn mk_zeroed_md(td: &mut TestDir) -> Result<PathBuf> {
let md = mk_path(dir.path(), "meta.bin"); let md = td.mk_path("meta.bin");
let _file = file_utils::create_sized_file(&md, 4096 * 4096); let _file = file_utils::create_sized_file(&md, 4096 * 4096);
Ok(md) Ok(md)
} }
pub fn accepts_flag(flag: &str) -> Result<()> { pub fn accepts_flag(flag: &str) -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let md = mk_valid_md(&dir)?; let md = mk_valid_md(&mut td)?;
thin_check!(flag, &md).run()?; thin_check!(flag, &md).run()?;
Ok(()) Ok(())
} }

20
tests/thin_check.rs
View File

@ -72,8 +72,8 @@ fn accepts_clear_needs_check_flag() -> Result<()> {
#[test] #[test]
fn accepts_quiet() -> Result<()> { fn accepts_quiet() -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let md = mk_valid_md(&dir)?; let md = mk_valid_md(&mut td)?;
let output = thin_check!("--quiet", &md).run()?; let output = thin_check!("--quiet", &md).run()?;
assert!(output.status.success()); assert!(output.status.success());
@ -84,8 +84,8 @@ fn accepts_quiet() -> Result<()> {
#[test] #[test]
fn detects_corrupt_superblock_with_superblock_only() -> Result<()> { fn detects_corrupt_superblock_with_superblock_only() -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let md = mk_zeroed_md(&dir)?; let md = mk_zeroed_md(&mut td)?;
let output = thin_check!("--super-block-only", &md).unchecked().run()?; let output = thin_check!("--super-block-only", &md).unchecked().run()?;
assert!(!output.status.success()); assert!(!output.status.success());
Ok(()) Ok(())
@ -93,8 +93,8 @@ fn detects_corrupt_superblock_with_superblock_only() -> Result<()> {
#[test] #[test]
fn prints_help_message_for_tiny_metadata() -> Result<()> { fn prints_help_message_for_tiny_metadata() -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let md = mk_path(dir.path(), "meta.bin"); let md = td.mk_path("meta.bin");
let _file = file_utils::create_sized_file(&md, 1024); let _file = file_utils::create_sized_file(&md, 1024);
let stderr = run_fail(thin_check!(&md))?; let stderr = run_fail(thin_check!(&md))?;
assert!(stderr.contains("Metadata device/file too small. Is this binary metadata?")); assert!(stderr.contains("Metadata device/file too small. Is this binary metadata?"));
@ -103,8 +103,8 @@ fn prints_help_message_for_tiny_metadata() -> Result<()> {
#[test] #[test]
fn spot_xml_data() -> Result<()> { fn spot_xml_data() -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let xml = mk_path(dir.path(), "meta.xml"); let xml = td.mk_path("meta.xml");
let mut gen = FragmentedS::new(4, 10240); let mut gen = FragmentedS::new(4, 10240);
write_xml(&xml, &mut gen)?; write_xml(&xml, &mut gen)?;
@ -119,8 +119,8 @@ fn spot_xml_data() -> Result<()> {
#[test] #[test]
fn prints_info_fields() -> Result<()> { fn prints_info_fields() -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let md = mk_valid_md(&dir)?; let md = mk_valid_md(&mut td)?;
let stdout = thin_check!(&md).read()?; let stdout = thin_check!(&md).read()?;
assert!(stdout.contains("TRANSACTION_ID=")); assert!(stdout.contains("TRANSACTION_ID="));
assert!(stdout.contains("METADATA_FREE_BLOCKS=")); assert!(stdout.contains("METADATA_FREE_BLOCKS="));

37
tests/thin_restore.rs
View File

@ -45,8 +45,8 @@ fn accepts_help() -> Result<()> {
#[test] #[test]
fn no_input_file() -> Result<()> { fn no_input_file() -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let md = mk_zeroed_md(&dir)?; let md = mk_zeroed_md(&mut td)?;
let stderr = run_fail(thin_restore!("-o", &md))?; let stderr = run_fail(thin_restore!("-o", &md))?;
assert!(stderr.contains("No input file provided.")); assert!(stderr.contains("No input file provided."));
Ok(()) Ok(())
@ -54,8 +54,8 @@ fn no_input_file() -> Result<()> {
#[test] #[test]
fn missing_input_file() -> Result<()> { fn missing_input_file() -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let md = mk_zeroed_md(&dir)?; let md = mk_zeroed_md(&mut td)?;
let stderr = run_fail(thin_restore!("-i", "no-such-file", "-o", &md))?; let stderr = run_fail(thin_restore!("-i", "no-such-file", "-o", &md))?;
assert!(superblock_all_zeroes(&md)?); assert!(superblock_all_zeroes(&md)?);
assert!(stderr.contains("Couldn't stat file")); assert!(stderr.contains("Couldn't stat file"));
@ -64,9 +64,9 @@ fn missing_input_file() -> Result<()> {
#[test] #[test]
fn garbage_input_file() -> Result<()> { fn garbage_input_file() -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let xml = mk_zeroed_md(&dir)?; let xml = mk_zeroed_md(&mut td)?;
let md = mk_zeroed_md(&dir)?; let md = mk_zeroed_md(&mut td)?;
let _stderr = run_fail(thin_restore!("-i", &xml, "-o", &md))?; let _stderr = run_fail(thin_restore!("-i", &xml, "-o", &md))?;
assert!(superblock_all_zeroes(&md)?); assert!(superblock_all_zeroes(&md)?);
Ok(()) Ok(())
@ -74,8 +74,8 @@ fn garbage_input_file() -> Result<()> {
#[test] #[test]
fn no_output_file() -> Result<()> { fn no_output_file() -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let xml = mk_valid_xml(&dir)?; let xml = mk_valid_xml(&mut td)?;
let stderr = run_fail(thin_restore!("-i", &xml))?; let stderr = run_fail(thin_restore!("-i", &xml))?;
assert!(stderr.contains("No output file provided.")); assert!(stderr.contains("No output file provided."));
Ok(()) Ok(())
@ -83,20 +83,19 @@ fn no_output_file() -> Result<()> {
#[test] #[test]
fn tiny_output_file() -> Result<()> { fn tiny_output_file() -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let xml = mk_valid_xml(&dir)?; let xml = mk_valid_xml(&mut td)?;
let md = mk_path(dir.path(), "meta.bin"); let md = td.mk_path("meta.bin");
let _file = file_utils::create_sized_file(&md, 4096); let _file = file_utils::create_sized_file(&md, 4096);
let stderr = run_fail(thin_restore!("-i", &xml, "-o", &md))?; let stderr = run_fail(thin_restore!("-i", &xml, "-o", &md))?;
eprintln!("{}", stderr);
assert!(stderr.contains("Output file too small")); assert!(stderr.contains("Output file too small"));
Ok(()) Ok(())
} }
fn quiet_flag(flag: &str) -> Result<()> { fn quiet_flag(flag: &str) -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let xml = mk_valid_xml(&dir)?; let xml = mk_valid_xml(&mut td)?;
let md = mk_zeroed_md(&dir)?; let md = mk_zeroed_md(&mut td)?;
let output = thin_restore!("-i", &xml, "-o", &md, flag).run()?; let output = thin_restore!("-i", &xml, "-o", &md, flag).run()?;
@ -117,9 +116,9 @@ fn accepts_quiet() -> Result<()> {
} }
fn override_something(flag: &str, value: &str, pattern: &str) -> Result<()> { fn override_something(flag: &str, value: &str, pattern: &str) -> Result<()> {
let dir = tempdir()?; let mut td = TestDir::new()?;
let xml = mk_valid_xml(&dir)?; let xml = mk_valid_xml(&mut td)?;
let md = mk_zeroed_md(&dir)?; let md = mk_zeroed_md(&mut td)?;
thin_restore!("-i", &xml, "-o", &md, flag, value).run()?; thin_restore!("-i", &xml, "-o", &md, flag, value).run()?;

12
tests/thin_shrink.rs
View File

@ -10,9 +10,9 @@ use thinp::file_utils;
use thinp::thin::xml::{self, Visit}; use thinp::thin::xml::{self, Visit};
mod common; mod common;
use common::mk_path; use common::*;
use common::xml_generator::{ use common::xml_generator::{
write_xml, EmptyPoolS, FragmentedS, SingleThinS, SnapS, XmlGen, write_xml, EmptyPoolS, FragmentedS, SingleThinS, SnapS, XmlGen
}; };
//------------------------------------ //------------------------------------
@ -296,10 +296,10 @@ fn test_shrink<S>(scenario: &mut S) -> Result<()>
where where
S: Scenario + XmlGen, S: Scenario + XmlGen,
{ {
let dir = tempdir()?; let mut td = TestDir::new()?;
let xml_before = mk_path(dir.path(), "before.xml"); let xml_before = td.mk_path("before.xml");
let xml_after = mk_path(dir.path(), "after.xml"); let xml_after = td.mk_path("after.xml");
let data_path = mk_path(dir.path(), "metadata.bin"); let data_path = td.mk_path("metadata.bin");
write_xml(&xml_before, scenario)?; write_xml(&xml_before, scenario)?;
create_data_file(&data_path, &xml_before)?; create_data_file(&data_path, &xml_before)?;