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

Merge rust tools into a single pdata_tools exe

Browse Source
This commit is contained in:
Joe Thornber
2021-10-11 12:07:26 +01:00
parent c9b47437f2
commit 024554c987
41 changed files with 840 additions and 567 deletions
Download Patch File Download Diff File Expand all files Collapse all files

56
tests/cache_check.rs
View File

@@ -13,16 +13,24 @@ use common::test_dir::*;
//------------------------------------------
const USAGE: &str = "Usage: cache_check [options] {device|file}\n\
Options:\n \
{-q|--quiet}\n \
{-h|--help}\n \
{-V|--version}\n \
{--clear-needs-check-flag}\n \
{--super-block-only}\n \
{--skip-mappings}\n \
{--skip-hints}\n \
{--skip-discards}";
const USAGE: &str =
"cache_check 0.9.0
USAGE:
cache_check [FLAGS] <INPUT>
FLAGS:
--auto-repair Auto repair trivial issues.
--ignore-non-fatal-errors Only return a non-zero exit code if a fatal error is found.
-q, --quiet Suppress output messages, return only exit code.
--super-block-only Only check the superblock.
--skip-discards Don't check the discard bitset
--skip-hints Don't check the hint array
-h, --help Prints help information
-V, --version Prints version information
ARGS:
<INPUT> Specify the input device to check";
//------------------------------------------
@@ -33,8 +41,12 @@ impl<'a> Program<'a> for CacheCheck {
"cache_check"
}
fn path() -> &'a std::ffi::OsStr {
CACHE_CHECK.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
cache_check_cmd(args)
}
fn usage() -> &'a str {
@@ -91,8 +103,9 @@ test_corrupted_input_data!(CacheCheck);
fn failing_q() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_zeroed_md(&mut td)?;
let output = run_fail_raw(CACHE_CHECK, args!["-q", &md])?;
let output = run_fail_raw(cache_check_cmd(args!["-q", &md]))?;
assert_eq!(output.stdout.len(), 0);
eprintln!("stderr = '{}'", std::str::from_utf8(&output.stderr).unwrap());
assert_eq!(output.stderr.len(), 0);
Ok(())
}
@@ -101,7 +114,7 @@ fn failing_q() -> Result<()> {
fn failing_quiet() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_zeroed_md(&mut td)?;
let output = run_fail_raw(CACHE_CHECK, args!["--quiet", &md])?;
let output = run_fail_raw(cache_check_cmd(args!["--quiet", &md]))?;
assert_eq!(output.stdout.len(), 0);
assert_eq!(output.stderr.len(), 0);
Ok(())
@@ -111,17 +124,23 @@ fn failing_quiet() -> Result<()> {
fn valid_metadata_passes() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
run_ok(CACHE_CHECK, args![&md])?;
run_ok(cache_check_cmd(args![&md]))?;
Ok(())
}
// FIXME: put back in, I don't want to add the --debug- arg to the
// tool again, so we should have a little library function for tweaking
// metadata version.
/*
#[test]
fn bad_metadata_version() -> Result<()> {
let mut td = TestDir::new()?;
let xml = mk_valid_xml(&mut td)?;
let md = mk_zeroed_md(&mut td)?;
run_ok(
CACHE_RESTORE,
cache_restore_cmd(
args![
"-i",
&xml,
@@ -130,7 +149,8 @@ fn bad_metadata_version() -> Result<()> {
"--debug-override-metadata-version",
"12345"
],
)?;
run_fail(CACHE_CHECK, args![&md])?;
))?;
run_fail(cache_check_cmd(args![&md]))?;
Ok(())
}
*/

36
tests/cache_dump.rs
View File

@@ -15,12 +15,22 @@ use common::test_dir::*;
//------------------------------------------
const USAGE: &str = "Usage: cache_dump [options] {device|file}\n\
Options:\n \
{-h|--help}\n \
{-o <xml file>}\n \
{-V|--version}\n \
{--repair}";
const USAGE: &str = "cache_dump 0.9.0
Dump the cache metadata to stdout in XML format
USAGE:
cache_dump [FLAGS] [OPTIONS] <INPUT>
FLAGS:
-r, --repair Repair the metadata whilst dumping it
-h, --help Prints help information
-V, --version Prints version information
OPTIONS:
-o, --output <FILE> Specify the output file rather than stdout
ARGS:
<INPUT> Specify the input device to dump";
//------------------------------------------
@@ -31,8 +41,12 @@ impl<'a> Program<'a> for CacheDump {
"cache_dump"
}
fn path() -> &'a std::ffi::OsStr {
CACHE_DUMP.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
cache_dump_cmd(args)
}
fn usage() -> &'a str {
@@ -84,7 +98,7 @@ test_unreadable_input_file!(CacheDump);
fn dump_restore_cycle() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
let output = run_ok_raw(CACHE_DUMP, args![&md])?;
let output = run_ok_raw(cache_dump_cmd(args![&md]))?;
let xml = td.mk_path("meta.xml");
let mut file = OpenOptions::new()
@@ -96,9 +110,9 @@ fn dump_restore_cycle() -> Result<()> {
drop(file);
let md2 = mk_zeroed_md(&mut td)?;
run_ok(CACHE_RESTORE, args!["-i", &xml, "-o", &md2])?;
run_ok(cache_restore_cmd(args!["-i", &xml, "-o", &md2]))?;
let output2 = run_ok_raw(CACHE_DUMP, args![&md2])?;
let output2 = run_ok_raw(cache_dump_cmd(args![&md2]))?;
assert_eq!(output.stdout, output2.stdout);
Ok(())

29
tests/cache_repair.rs
View File

@@ -12,12 +12,21 @@ use common::test_dir::*;
//------------------------------------------
const USAGE: &str = "Usage: cache_repair [options] {device|file}\n\
Options:\n \
{-h|--help}\n \
{-i|--input} <input metadata (binary format)>\n \
{-o|--output} <output metadata (binary format)>\n \
{-V|--version}";
const USAGE: &str =
"cache_repair 0.9.0
Repair binary cache metadata, and write it to a different device or file
USAGE:
cache_repair [FLAGS] --input <FILE> --output <FILE>
FLAGS:
-q, --quiet Suppress output messages, return only exit code.
-h, --help Prints help information
-V, --version Prints version information
OPTIONS:
-i, --input <FILE> Specify the input device
-o, --output <FILE> Specify the output device";
//-----------------------------------------
@@ -28,8 +37,12 @@ impl<'a> Program<'a> for CacheRepair {
"cache_repair"
}
fn path() -> &'a std::ffi::OsStr {
CACHE_REPAIR.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
cache_repair_cmd(args)
}
fn usage() -> &'a str {

52
tests/cache_restore.rs
View File

@@ -14,17 +14,21 @@ use common::test_dir::*;
//------------------------------------------
const USAGE: &str = "Usage: cache_restore [options]\n\
Options:\n \
{-h|--help}\n \
{-i|--input} <input xml file>\n \
{-o|--output} <output device or file>\n \
{-q|--quiet}\n \
{--metadata-version} <1 or 2>\n \
{-V|--version}\n\
\n \
{--debug-override-metadata-version} <integer>\n \
{--omit-clean-shutdown}";
const USAGE: &str =
"cache_restore 0.9.0
Convert XML format metadata to binary.
USAGE:
cache_restore [FLAGS] --input <FILE> --output <FILE>
FLAGS:
-q, --quiet Suppress output messages, return only exit code.
-h, --help Prints help information
-V, --version Prints version information
OPTIONS:
-i, --input <FILE> Specify the input xml
-o, --output <FILE> Specify the output device to check";
//------------------------------------------
@@ -35,8 +39,12 @@ impl<'a> Program<'a> for CacheRestore {
"thin_restore"
}
fn path() -> &'a std::ffi::OsStr {
CACHE_RESTORE.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
cache_restore_cmd(args)
}
fn usage() -> &'a str {
@@ -105,7 +113,7 @@ fn quiet_flag(flag: &str) -> Result<()> {
let xml = mk_valid_xml(&mut td)?;
let md = mk_zeroed_md(&mut td)?;
let output = run_ok_raw(CACHE_RESTORE, args!["-i", &xml, "-o", &md, flag])?;
let output = run_ok_raw(cache_restore_cmd(args!["-i", &xml, "-o", &md, flag]))?;
assert_eq!(output.stdout.len(), 0);
assert_eq!(output.stderr.len(), 0);
@@ -129,17 +137,19 @@ fn successfully_restores() -> Result<()> {
let mut td = TestDir::new()?;
let xml = mk_valid_xml(&mut td)?;
let md = mk_zeroed_md(&mut td)?;
run_ok(CACHE_RESTORE, args!["-i", &xml, "-o", &md])?;
run_ok(cache_restore_cmd(args!["-i", &xml, "-o", &md]))?;
Ok(())
}
// FIXME: finish
/*
#[test]
fn override_metadata_version() -> Result<()> {
let mut td = TestDir::new()?;
let xml = mk_valid_xml(&mut td)?;
let md = mk_zeroed_md(&mut td)?;
run_ok(
CACHE_RESTORE,
cache_restore_cmd(
args![
"-i",
&xml,
@@ -148,20 +158,24 @@ fn override_metadata_version() -> Result<()> {
"--debug-override-metadata-version",
"10298"
],
)?;
))?;
Ok(())
}
*/
// FIXME: finish
/*
#[test]
fn accepts_omit_clean_shutdown() -> Result<()> {
let mut td = TestDir::new()?;
let xml = mk_valid_xml(&mut td)?;
let md = mk_zeroed_md(&mut td)?;
run_ok(
CACHE_RESTORE,
cache_restore_cmd(
args!["-i", &xml, "-o", &md, "--omit-clean-shutdown"],
)?;
))?;
Ok(())
}
*/
//-----------------------------------------

2
tests/common/cache.rs
View File

@@ -27,7 +27,7 @@ pub fn mk_valid_md(td: &mut TestDir) -> Result<PathBuf> {
write_xml(&xml, &mut gen)?;
let _file = file_utils::create_sized_file(&md, 4096 * 4096);
run_ok(CACHE_RESTORE, args!["-i", &xml, "-o", &md])?;
run_ok(cache_restore_cmd(args!["-i", &xml, "-o", &md]))?;
Ok(md)
}

10
tests/common/common_args.rs
View File

@@ -13,7 +13,7 @@ pub fn test_help_short<'a, P>() -> Result<()>
where
P: Program<'a>,
{
let stdout = run_ok(P::path(), args!["-h"])?;
let stdout = run_ok(P::cmd(args!["-h"]))?;
assert_eq!(stdout, P::usage());
Ok(())
}
@@ -22,7 +22,7 @@ pub fn test_help_long<'a, P>() -> Result<()>
where
P: Program<'a>,
{
let stdout = run_ok(P::path(), args!["--help"])?;
let stdout = run_ok(P::cmd(vec!["--help"]))?;
assert_eq!(stdout, P::usage());
Ok(())
}
@@ -49,7 +49,7 @@ pub fn test_version_short<'a, P>() -> Result<()>
where
P: Program<'a>,
{
let stdout = run_ok(P::path(), args!["-V"])?;
let stdout = run_ok(P::cmd(args!["-V"]))?;
assert!(stdout.contains(tools_version()));
Ok(())
}
@@ -58,7 +58,7 @@ pub fn test_version_long<'a, P>() -> Result<()>
where
P: Program<'a>,
{
let stdout = run_ok(P::path(), args!["--version"])?;
let stdout = run_ok(P::cmd(args!["--version"]))?;
assert!(stdout.contains(tools_version()));
Ok(())
}
@@ -85,7 +85,7 @@ where
P: Program<'a>,
{
let option = "--hedgehogs-only";
let stderr = run_fail(P::path(), args![option])?;
let stderr = run_fail(P::cmd(args![option]))?;
assert!(stderr.contains(&P::bad_option_hint(option)));
Ok(())
}

21
tests/common/input_arg.rs
View File

@@ -63,7 +63,7 @@ where
P: InputProgram<'a>,
{
let args: [&str; 0] = [];
let stderr = run_fail(P::path(), args)?;
let stderr = run_fail(P::cmd(args))?;
assert!(stderr.contains(P::missing_input_arg()));
Ok(())
}
@@ -85,7 +85,7 @@ where
let mut td = TestDir::new()?;
let output = mk_zeroed_md(&mut td)?;
ensure_untouched(&output, || {
let stderr = run_fail(P::path(), args!["-o", &output])?;
let stderr = run_fail(P::cmd(args!["-o", &output]))?;
assert!(stderr.contains(P::missing_input_arg()));
Ok(())
})
@@ -109,7 +109,7 @@ where
let wrapper = build_args_fn(P::arg_type())?;
wrapper(&mut td, "no-such-file".as_ref(), &|args: &[&OsStr]| {
let stderr = run_fail(P::path(), args)?;
let stderr = run_fail(P::cmd(args))?;
assert!(stderr.contains(P::file_not_found()));
Ok(())
})
@@ -133,7 +133,7 @@ where
let wrapper = build_args_fn(P::arg_type())?;
wrapper(&mut td, "/tmp".as_ref(), &|args: &[&OsStr]| {
let stderr = run_fail(P::path(), args)?;
let stderr = run_fail(P::cmd(args))?;
assert!(stderr.contains("Not a block device or regular file"));
Ok(())
})
@@ -161,7 +161,7 @@ where
let wrapper = build_args_fn(P::arg_type())?;
wrapper(&mut td, input.as_ref(), &|args: &[&OsStr]| {
let stderr = run_fail(P::path(), args)?;
let stderr = run_fail(P::cmd(args))?;
assert!(stderr.contains("Permission denied"));
Ok(())
})
@@ -191,7 +191,8 @@ where
let wrapper = build_args_fn(P::arg_type())?;
wrapper(&mut td, input.as_ref(), &|args: &[&OsStr]| {
let stderr = run_fail(P::path(), args)?;
let stderr = run_fail(P::cmd(args))?;
eprintln!("actual: {:?}", stderr);
assert!(stderr.contains("Metadata device/file too small. Is this binary metadata?"));
Ok(())
})
@@ -220,11 +221,9 @@ where
let wrapper = build_args_fn(P::arg_type())?;
wrapper(&mut td, input.as_ref(), &|args: &[&OsStr]| {
let stderr = run_fail(P::path(), args)?;
eprintln!("{}", stderr);
let stderr = run_fail(P::cmd(args))?;
let msg = format!(
"This looks like XML. {} only checks the binary metadata format.",
P::name()
"This looks like XML. This tool only checks the binary metadata format.",
);
assert!(stderr.contains(&msg));
Ok(())
@@ -253,7 +252,7 @@ where
ArgType::IoOptions => with_output_superblock_zeroed,
};
wrapper(&mut td, input.as_ref(), &|args: &[&OsStr]| {
let stderr = run_fail(P::path(), args)?;
let stderr = run_fail(P::cmd(args))?;
assert!(stderr.contains(P::corrupted_input()));
Ok(())
})

12
tests/common/output_option.rs
View File

@@ -16,7 +16,7 @@ where
{
let mut td = TestDir::new()?;
let input = P::mk_valid_input(&mut td)?;
let stderr = run_fail(P::path(), args!["-i", &input])?;
let stderr = run_fail(P::cmd(args!["-i", &input]))?;
assert!(stderr.contains(P::missing_output_arg()));
Ok(())
}
@@ -37,7 +37,9 @@ where
{
let mut td = TestDir::new()?;
let input = P::mk_valid_input(&mut td)?;
let stderr = run_fail(P::path(), args!["-i", &input, "-o", "no-such-file"])?;
let cmd = P::cmd(args!["-i", &input, "-o", "no-such-file"]);
let stderr = run_fail(cmd)?;
assert!(stderr.contains(<P as MetadataWriter>::file_not_found()));
Ok(())
}
@@ -58,7 +60,7 @@ where
{
let mut td = TestDir::new()?;
let input = P::mk_valid_input(&mut td)?;
let stderr = run_fail(P::path(), args!["-i", &input, "-o", "/tmp"])?;
let stderr = run_fail(P::cmd(args!["-i", &input, "-o", "/tmp"]))?;
assert!(stderr.contains("Not a block device or regular file"));
Ok(())
}
@@ -84,7 +86,7 @@ where
let _file = file_utils::create_sized_file(&output, 4_194_304);
duct::cmd!("chmod", "-w", &output).run()?;
let stderr = run_fail(P::path(), args!["-i", &input, "-o", &output])?;
let stderr = run_fail(P::cmd(args!["-i", &input, "-o", &output]))?;
assert!(stderr.contains("Permission denied"));
Ok(())
}
@@ -113,7 +115,7 @@ where
let output = td.mk_path("meta.bin");
let _file = file_utils::create_sized_file(&output, 4096);
let stderr = run_fail(P::path(), args!["-i", &input, "-o", &output])?;
let stderr = run_fail(P::cmd(args!["-i", &input, "-o", &output]))?;
assert!(stderr.contains("Output file too small"));
Ok(())
}

46
tests/common/process.rs
View File

@@ -1,5 +1,4 @@
use anyhow::Result;
use std::ffi::{OsStr, OsString};
//------------------------------------------
@@ -15,49 +14,29 @@ macro_rules! args {
}
// Returns stdout. The command must return zero.
pub fn run_ok<S, I>(program: S, args: I) -> Result<String>
where
S: AsRef<OsStr>,
I: IntoIterator,
I::Item: Into<OsString>,
{
let command = duct::cmd(program.as_ref(), args)
.stdout_capture()
.stderr_capture();
pub fn run_ok(command: duct::Expression) -> Result<String> {
let command = command.stdout_capture().stderr_capture();
let output = command.run()?;
assert!(output.status.success());
let stdout = std::str::from_utf8(&output.stdout[..])
.unwrap()
.trim_end_matches(|c| c == '\n' || c == '\r')
.to_string();
Ok(stdout)
}
// Returns the entire output. The command must return zero.
pub fn run_ok_raw<S, I>(program: S, args: I) -> Result<std::process::Output>
where
S: AsRef<OsStr>,
I: IntoIterator,
I::Item: Into<OsString>,
{
let command = duct::cmd(program.as_ref(), args)
.stdout_capture()
.stderr_capture();
pub fn run_ok_raw(command: duct::Expression) -> Result<std::process::Output> {
let command = command.stdout_capture().stderr_capture();
let output = command.run()?;
assert!(output.status.success());
Ok(output)
}
// Returns stderr, a non zero status must be returned
pub fn run_fail<S, I>(program: S, args: I) -> Result<String>
where
S: AsRef<OsStr>,
I: IntoIterator,
I::Item: Into<OsString>,
{
let command = duct::cmd(program.as_ref(), args)
.stdout_capture()
.stderr_capture();
pub fn run_fail(command: duct::Expression) -> Result<String> {
let command = command.stdout_capture().stderr_capture();
let output = command.unchecked().run()?;
assert!(!output.status.success());
let stderr = std::str::from_utf8(&output.stderr[..]).unwrap().to_string();
@@ -65,15 +44,8 @@ where
}
// Returns the entire output, a non zero status must be returned
pub fn run_fail_raw<S, I>(program: S, args: I) -> Result<std::process::Output>
where
S: AsRef<OsStr>,
I: IntoIterator,
I::Item: Into<OsString>,
{
let command = duct::cmd(program.as_ref(), args)
.stdout_capture()
.stderr_capture();
pub fn run_fail_raw(command: duct::Expression) -> Result<std::process::Output> {
let command = command.stdout_capture().stderr_capture();
let output = command.unchecked().run()?;
assert!(!output.status.success());
Ok(output)

6
tests/common/program.rs
View File

@@ -1,5 +1,4 @@
use anyhow::Result;
use std::ffi::OsStr;
use std::path::PathBuf;
use crate::common::test_dir::TestDir;
@@ -13,7 +12,10 @@ pub enum ArgType {
pub trait Program<'a> {
fn name() -> &'a str;
fn path() -> &'a OsStr;
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>;
fn usage() -> &'a str;
fn arg_type() -> ArgType;

211
tests/common/target.rs
View File

@@ -1,69 +1,159 @@
//------------------------------------------
#[macro_export]
macro_rules! path_to_cpp {
($name: literal) => {
concat!("bin/", $name)
};
}
#[macro_export]
macro_rules! path_to_rust {
($name: literal) => {
env!(concat!("CARGO_BIN_EXE_", $name))
};
}
#[cfg(not(feature = "rust_tests"))]
#[macro_export]
macro_rules! path_to {
($name: literal) => {
path_to_cpp!($name)
};
}
#[cfg(feature = "rust_tests")]
#[macro_export]
macro_rules! path_to {
($name: literal) => {
path_to_rust!($name)
};
}
use std::ffi::OsString;
use std::path::PathBuf;
//------------------------------------------
pub const CACHE_CHECK: &str = path_to!("cache_check");
pub const CACHE_DUMP: &str = path_to!("cache_dump");
pub const CACHE_REPAIR: &str = path_to!("cache_repair");
pub const CACHE_RESTORE: &str = path_to!("cache_restore");
pub fn cpp_cmd<S, I>(cmd: S, args: I) -> duct::Expression
where
S: Into<OsString>,
I: IntoIterator,
I::Item: Into<OsString>,
{
let mut bin = PathBuf::from("./bin");
bin.push(Into::<OsString>::into(cmd));
duct::cmd(bin.as_path(), args)
}
pub const THIN_CHECK: &str = path_to!("thin_check");
pub const THIN_DELTA: &str = path_to_cpp!("thin_delta"); // TODO: rust version
pub const THIN_DUMP: &str = path_to!("thin_dump");
pub const THIN_METADATA_PACK: &str = path_to_rust!("thin_metadata_pack"); // rust-only
pub const THIN_METADATA_UNPACK: &str = path_to_rust!("thin_metadata_unpack"); // rust-only
pub const THIN_REPAIR: &str = path_to!("thin_repair");
pub const THIN_RESTORE: &str = path_to!("thin_restore");
pub const THIN_RMAP: &str = path_to_cpp!("thin_rmap"); // TODO: rust version
pub const THIN_GENERATE_METADATA: &str = path_to_cpp!("thin_generate_metadata"); // cpp-only
pub const THIN_GENERATE_MAPPINGS: &str = path_to_cpp!("thin_generate_mappings"); // cpp-only
pub const THIN_GENERATE_DAMAGE: &str = path_to_cpp!("thin_generate_damage"); // cpp-only
pub fn rust_cmd<S, I>(cmd: S, args: I) -> duct::Expression
where
S: Into<OsString>,
I: IntoIterator,
I::Item: Into<OsString>,
{
const RUST_PATH: &str = env!(concat!("CARGO_BIN_EXE_", "pdata_tools"));
//------------------------------------------
pub mod cpp_msg {
pub const FILE_NOT_FOUND: &str = "No such file or directory";
pub const MISSING_INPUT_ARG: &str = "No input file provided";
pub const MISSING_OUTPUT_ARG: &str = "No output file provided";
pub const BAD_SUPERBLOCK: &str = "bad checksum in superblock";
pub fn bad_option_hint(option: &str) -> String {
format!("unrecognized option '{}'", option)
let mut all_args = vec![Into::<OsString>::into(cmd)];
for a in args {
all_args.push(Into::<OsString>::into(a));
}
duct::cmd(RUST_PATH, &all_args)
}
pub mod rust_msg {
pub const FILE_NOT_FOUND: &str = "No such file or directory";
pub fn thin_check_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
rust_cmd("thin_check", args)
}
pub fn thin_rmap_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
cpp_cmd("thin_rmap", args)
}
pub fn thin_generate_metadata_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
cpp_cmd("thin_generate_metadata", args)
}
pub fn thin_generate_mappings_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
cpp_cmd("thin_generate_mappings", args)
}
pub fn thin_generate_damage_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
cpp_cmd("thin_generate_damage", args)
}
pub fn thin_restore_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
rust_cmd("thin_restore", args)
}
pub fn thin_repair_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
rust_cmd("thin_restore", args)
}
pub fn thin_dump_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
rust_cmd("thin_dump", args)
}
pub fn thin_delta_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
cpp_cmd("thin_delta", args)
}
pub fn thin_metadata_pack_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
rust_cmd("thin_metadata_pack", args)
}
pub fn thin_metadata_unpack_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
rust_cmd("thin_metadata_unpack", args)
}
pub fn cache_check_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
rust_cmd("cache_check", args)
}
pub fn cache_dump_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
rust_cmd("cache_dump", args)
}
pub fn cache_restore_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
rust_cmd("cache_restore", args)
}
pub fn cache_repair_cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<OsString>,
{
rust_cmd("cache_repair", args)
}
//------------------------------------------
pub mod msg {
pub const FILE_NOT_FOUND: &str = "Couldn't find input file";
pub const MISSING_INPUT_ARG: &str = "The following required arguments were not provided"; // TODO: be specific
pub const MISSING_OUTPUT_ARG: &str = "The following required arguments were not provided"; // TODO: be specific
pub const BAD_SUPERBLOCK: &str = "bad checksum in superblock";
@@ -73,9 +163,4 @@ pub mod rust_msg {
}
}
#[cfg(not(feature = "rust_tests"))]
pub use cpp_msg as msg;
#[cfg(feature = "rust_tests")]
pub use rust_msg as msg;
//------------------------------------------

16
tests/common/thin.rs
View File

@@ -28,7 +28,7 @@ pub fn mk_valid_md(td: &mut TestDir) -> Result<PathBuf> {
write_xml(&xml, &mut gen)?;
let _file = file_utils::create_sized_file(&md, 4096 * 4096);
run_ok(THIN_RESTORE, args!["-i", &xml, "-o", &md])?;
run_ok(thin_restore_cmd(args!["-i", &xml, "-o", &md]))?;
Ok(md)
}
@@ -39,11 +39,11 @@ pub fn mk_valid_md(td: &mut TestDir) -> Result<PathBuf> {
pub fn prep_metadata(td: &mut TestDir) -> Result<PathBuf> {
let md = mk_zeroed_md(td)?;
let args = args!["-o", &md, "--format", "--nr-data-blocks", "102400"];
run_ok(THIN_GENERATE_METADATA, args)?;
run_ok(thin_generate_metadata_cmd(args))?;
// Create a 2GB device
let args = args!["-o", &md, "--create-thin", "1"];
run_ok(THIN_GENERATE_METADATA, args)?;
run_ok(thin_generate_metadata_cmd(args))?;
let args = args![
"-o",
&md,
@@ -54,7 +54,7 @@ pub fn prep_metadata(td: &mut TestDir) -> Result<PathBuf> {
"--rw=randwrite",
"--seq-nr=16"
];
run_ok(THIN_GENERATE_MAPPINGS, args)?;
run_ok(thin_generate_mappings_cmd(args))?;
// Take a few snapshots.
let mut snap_id = 2;
@@ -62,7 +62,7 @@ pub fn prep_metadata(td: &mut TestDir) -> Result<PathBuf> {
// take a snapshot
let snap_id_str = snap_id.to_string();
let args = args!["-o", &md, "--create-snap", &snap_id_str, "--origin", "1"];
run_ok(THIN_GENERATE_METADATA, args)?;
run_ok(thin_generate_metadata_cmd(args))?;
// partially overwrite the origin (64MB)
let args = args![
@@ -77,7 +77,7 @@ pub fn prep_metadata(td: &mut TestDir) -> Result<PathBuf> {
"--rw=randwrite",
"--seq-nr=16"
];
run_ok(THIN_GENERATE_MAPPINGS, args)?;
run_ok(thin_generate_mappings_cmd(args))?;
snap_id += 1;
}
@@ -86,7 +86,7 @@ pub fn prep_metadata(td: &mut TestDir) -> Result<PathBuf> {
pub fn set_needs_check(md: &PathBuf) -> Result<()> {
let args = args!["-o", &md, "--set-needs-check"];
run_ok(THIN_GENERATE_METADATA, args)?;
run_ok(thin_generate_metadata_cmd(args))?;
Ok(())
}
@@ -110,7 +110,7 @@ pub fn generate_metadata_leaks(
"--actual",
&actual_str
];
run_ok(THIN_GENERATE_DAMAGE, args)?;
run_ok(thin_generate_damage_cmd(args))?;
Ok(())
}

160
tests/thin_check.rs
View File

@@ -13,18 +13,28 @@ use common::thin::*;
//------------------------------------------
const USAGE: &str = "Usage: thin_check [options] {device|file}\n\
Options:\n \
{-q|--quiet}\n \
{-h|--help}\n \
{-V|--version}\n \
{-m|--metadata-snap}\n \
{--auto-repair}\n \
{--override-mapping-root}\n \
{--clear-needs-check-flag}\n \
{--ignore-non-fatal-errors}\n \
{--skip-mappings}\n \
{--super-block-only}";
const USAGE: &str = "thin_check 0.9.0
Validates thin provisioning metadata on a device or file.
USAGE:
thin_check [FLAGS] [OPTIONS] <INPUT>
FLAGS:
--auto-repair Auto repair trivial issues.
--clear-needs-check-flag Clears the 'needs_check' flag in the superblock
--ignore-non-fatal-errors Only return a non-zero exit code if a fatal error is found.
-m, --metadata-snapshot Check the metadata snapshot on a live pool
-q, --quiet Suppress output messages, return only exit code.
--super-block-only Only check the superblock.
--skip-mappings Don't check the mapping tree
-h, --help Prints help information
-V, --version Prints version information
OPTIONS:
--override-mapping-root <OVERRIDE_MAPPING_ROOT> Specify a mapping root to use
ARGS:
<INPUT> Specify the input device to check";
//-----------------------------------------
@@ -35,8 +45,12 @@ impl<'a> Program<'a> for ThinCheck {
"thin_check"
}
fn path() -> &'a std::ffi::OsStr {
THIN_CHECK.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
thin_check_cmd(args)
}
fn usage() -> &'a str {
@@ -93,7 +107,7 @@ test_corrupted_input_data!(ThinCheck);
fn accepts_flag(flag: &str) -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
run_ok(THIN_CHECK, args![flag, &md])?;
run_ok(thin_check_cmd(args![flag, &md]))?;
Ok(())
}
@@ -130,7 +144,14 @@ fn accepts_quiet() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
let output = run_ok_raw(THIN_CHECK, args!["--quiet", &md])?;
let output = run_ok_raw(thin_check_cmd(args!["--quiet", &md]))?;
if output.stdout.len() > 0 {
eprintln!("stdout: {:?}", &std::str::from_utf8(&output.stdout));
}
if output.stderr.len() > 0 {
eprintln!("stderr: {:?}", &std::str::from_utf8(&output.stderr));
}
assert_eq!(output.stdout.len(), 0);
assert_eq!(output.stderr.len(), 0);
Ok(())
@@ -143,7 +164,7 @@ fn accepts_quiet() -> Result<()> {
fn detects_corrupt_superblock_with_superblock_only() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_zeroed_md(&mut td)?;
let _stderr = run_fail(THIN_CHECK, args!["--super-block-only", &md])?;
let _stderr = run_fail(thin_check_cmd(args!["--super-block-only", &md]))?;
Ok(())
}
@@ -154,7 +175,8 @@ fn detects_corrupt_superblock_with_superblock_only() -> Result<()> {
fn prints_info_fields() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
let stdout = run_ok(THIN_CHECK, args![&md])?;
let stdout = run_ok(thin_check_cmd(args![&md]))?;
eprintln!("info: {:?}", stdout);
assert!(stdout.contains("TRANSACTION_ID="));
assert!(stdout.contains("METADATA_FREE_BLOCKS="));
Ok(())
@@ -167,20 +189,28 @@ fn prints_info_fields() -> Result<()> {
fn auto_repair_incompatible_opts() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
run_fail(THIN_CHECK, args!["--auto-repair", "-m", &md])?;
run_fail(
THIN_CHECK,
args!["--auto-repair", "--override-mapping-root", "123", &md],
)?;
run_fail(
THIN_CHECK,
args!["--auto-repair", "--super-block-only", &md],
)?;
run_fail(THIN_CHECK, args!["--auto-repair", "--skip-mappings", &md])?;
run_fail(
THIN_CHECK,
args!["--auto-repair", "--ignore-non-fatal-errors", &md],
)?;
run_fail(thin_check_cmd(args!["--auto-repair", "-m", &md]))?;
run_fail(thin_check_cmd(args![
"--auto-repair",
"--override-mapping-root",
"123",
&md
]))?;
run_fail(thin_check_cmd(args![
"--auto-repair",
"--super-block-only",
&md
]))?;
run_fail(thin_check_cmd(args![
"--auto-repair",
"--skip-mappings",
&md
]))?;
run_fail(thin_check_cmd(args![
"--auto-repair",
"--ignore-non-fatal-errors",
&md
]))?;
Ok(())
}
@@ -188,24 +218,23 @@ fn auto_repair_incompatible_opts() -> Result<()> {
fn clear_needs_check_incompatible_opts() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
run_fail(THIN_CHECK, args!["--clear-needs-check-flag", "-m", &md])?;
run_fail(
THIN_CHECK,
args![
"--clear-needs-check-flag",
"--override-mapping-root",
"123",
&md
],
)?;
run_fail(
THIN_CHECK,
args!["--clear-needs-check-flag", "--super-block-only", &md],
)?;
run_fail(
THIN_CHECK,
args!["--clear-needs-check-flag", "--ignore-non-fatal-errors", &md],
)?;
run_fail(thin_check_cmd(args!["--clear-needs-check-flag", "-m", &md]))?;
run_fail(thin_check_cmd(args![
"--clear-needs-check-flag",
"--override-mapping-root",
"123",
&md
]))?;
run_fail(thin_check_cmd(args![
"--clear-needs-check-flag",
"--super-block-only",
&md
]))?;
run_fail(thin_check_cmd(args![
"--clear-needs-check-flag",
"--ignore-non-fatal-errors",
&md
]))?;
Ok(())
}
@@ -220,7 +249,7 @@ fn clear_needs_check() -> Result<()> {
set_needs_check(&md)?;
assert!(get_needs_check(&md)?);
run_ok(THIN_CHECK, args!["--clear-needs-check-flag", &md])?;
run_ok(thin_check_cmd(args!["--clear-needs-check-flag", &md]))?;
assert!(!get_needs_check(&md)?);
Ok(())
}
@@ -232,7 +261,7 @@ fn no_clear_needs_check_if_error() -> Result<()> {
set_needs_check(&md)?;
generate_metadata_leaks(&md, 1, 0, 1)?;
run_fail(THIN_CHECK, args!["--clear-needs-check-flag", &md])?;
run_fail(thin_check_cmd(args!["--clear-needs-check-flag", &md]))?;
assert!(get_needs_check(&md)?);
Ok(())
}
@@ -246,10 +275,11 @@ fn clear_needs_check_if_skip_mappings() -> Result<()> {
generate_metadata_leaks(&md, 1, 0, 1)?;
assert!(get_needs_check(&md)?);
run_ok(
THIN_CHECK,
args!["--clear-needs-check-flag", "--skip-mappings", &md],
)?;
run_ok(thin_check_cmd(args![
"--clear-needs-check-flag",
"--skip-mappings",
&md
]))?;
assert!(!get_needs_check(&md)?);
Ok(())
}
@@ -262,8 +292,8 @@ fn metadata_leaks_are_non_fatal() -> Result<()> {
let mut td = TestDir::new()?;
let md = prep_metadata(&mut td)?;
generate_metadata_leaks(&md, 1, 0, 1)?;
run_fail(THIN_CHECK, args![&md])?;
run_ok(THIN_CHECK, args!["--ignore-non-fatal-errors", &md])?;
run_fail(thin_check_cmd(args![&md]))?;
run_ok(thin_check_cmd(args!["--ignore-non-fatal-errors", &md]))?;
Ok(())
}
@@ -274,7 +304,7 @@ fn fatal_errors_cant_be_ignored() -> Result<()> {
generate_metadata_leaks(&md, 1, 1, 0)?;
ensure_untouched(&md, || {
run_fail(THIN_CHECK, args!["--ignore-non-fatal-errors", &md])?;
run_fail(thin_check_cmd(args!["--ignore-non-fatal-errors", &md]))?;
Ok(())
})
}
@@ -289,14 +319,14 @@ fn auto_repair() -> Result<()> {
// auto-repair should have no effect on good metadata.
ensure_untouched(&md, || {
run_ok(THIN_CHECK, args!["--auto-repair", &md])?;
run_ok(thin_check_cmd(args!["--auto-repair", &md]))?;
Ok(())
})?;
generate_metadata_leaks(&md, 16, 0, 1)?;
run_fail(THIN_CHECK, args![&md])?;
run_ok(THIN_CHECK, args!["--auto-repair", &md])?;
run_ok(THIN_CHECK, args![&md])?;
run_fail(thin_check_cmd(args![&md]))?;
run_ok(thin_check_cmd(args!["--auto-repair", &md]))?;
run_ok(thin_check_cmd(args![&md]))?;
Ok(())
}
@@ -307,7 +337,7 @@ fn auto_repair_has_limits() -> Result<()> {
generate_metadata_leaks(&md, 16, 1, 0)?;
ensure_untouched(&md, || {
run_fail(THIN_CHECK, args!["--auto-repair", &md])?;
run_fail(thin_check_cmd(args!["--auto-repair", &md]))?;
Ok(())
})?;
Ok(())
@@ -319,7 +349,7 @@ fn auto_repair_clears_needs_check() -> Result<()> {
let md = prep_metadata(&mut td)?;
set_needs_check(&md)?;
run_ok(THIN_CHECK, args!["--auto-repair", &md])?;
run_ok(thin_check_cmd(args!["--auto-repair", &md]))?;
assert!(!get_needs_check(&md)?);
Ok(())
}

16
tests/thin_delta.rs
View File

@@ -29,8 +29,12 @@ impl<'a> Program<'a> for ThinDelta {
"thin_delta"
}
fn path() -> &'a std::ffi::OsStr {
THIN_DELTA.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
rust_cmd("thin_delta", args)
}
fn usage() -> &'a str {
@@ -42,7 +46,7 @@ impl<'a> Program<'a> for ThinDelta {
}
fn bad_option_hint(option: &str) -> String {
cpp_msg::bad_option_hint(option)
msg::bad_option_hint(option)
}
}
@@ -58,7 +62,7 @@ test_rejects_bad_option!(ThinDelta);
fn snap1_unspecified() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
let stderr = run_fail(THIN_DELTA, args!["--snap2", "45", &md])?;
let stderr = run_fail(thin_delta_cmd(args!["--snap2", "45", &md]))?;
assert!(stderr.contains("--snap1 or --root1 not specified"));
Ok(())
}
@@ -67,14 +71,14 @@ fn snap1_unspecified() -> Result<()> {
fn snap2_unspecified() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
let stderr = run_fail(THIN_DELTA, args!["--snap1", "45", &md])?;
let stderr = run_fail(thin_delta_cmd(args!["--snap1", "45", &md]))?;
assert!(stderr.contains("--snap2 or --root2 not specified"));
Ok(())
}
#[test]
fn dev_unspecified() -> Result<()> {
let stderr = run_fail(THIN_DELTA, args!["--snap1", "45", "--snap2", "46"])?;
let stderr = run_fail(thin_delta_cmd(args!["--snap1", "45", "--snap2", "46"]))?;
// TODO: replace with msg::MISSING_INPUT_ARG once the rust version is ready
assert!(stderr.contains("No input file provided"));
Ok(())

37
tests/thin_dump.rs
View File

@@ -35,8 +35,12 @@ impl<'a> Program<'a> for ThinDump {
"thin_dump"
}
fn path() -> &'a std::ffi::OsStr {
THIN_DUMP.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
thin_dump_cmd(args)
}
fn usage() -> &'a str {
@@ -89,7 +93,7 @@ fn dump_restore_cycle() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
let output = run_ok_raw(THIN_DUMP, args![&md])?;
let output = run_ok_raw(thin_dump_cmd(args![&md]))?;
let xml = td.mk_path("meta.xml");
let mut file = OpenOptions::new()
@@ -101,9 +105,9 @@ fn dump_restore_cycle() -> Result<()> {
drop(file);
let md2 = mk_zeroed_md(&mut td)?;
run_ok(THIN_RESTORE, args!["-i", &xml, "-o", &md2])?;
run_ok(thin_restore_cmd(args!["-i", &xml, "-o", &md2]))?;
let output2 = run_ok_raw(THIN_DUMP, args![&md2])?;
let output2 = run_ok_raw(thin_dump_cmd(args![&md2]))?;
assert_eq!(output.stdout, output2.stdout);
Ok(())
@@ -118,7 +122,7 @@ fn no_stderr() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
let output = run_ok_raw(THIN_DUMP, args![&md])?;
let output = run_ok_raw(thin_dump_cmd(args![&md]))?;
assert_eq!(output.stderr.len(), 0);
Ok(())
@@ -132,7 +136,7 @@ fn no_stderr() -> Result<()> {
fn override_something(flag: &str, value: &str, pattern: &str) -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
let output = run_ok_raw(THIN_DUMP, args![&md, flag, value])?;
let output = run_ok_raw(thin_dump_cmd(args![&md, flag, value]))?;
if !cfg!(feature = "rust_tests") {
assert_eq!(output.stderr.len(), 0);
@@ -164,11 +168,10 @@ fn override_nr_data_blocks() -> Result<()> {
fn repair_superblock() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
let before = run_ok_raw(THIN_DUMP, args![&md])?;
let before = run_ok_raw(thin_dump_cmd(args![&md]))?;
damage_superblock(&md)?;
let after = run_ok_raw(
THIN_DUMP,
let after = run_ok_raw(thin_dump_cmd(
args![
"--repair",
"--transaction-id=1",
@@ -176,7 +179,7 @@ fn repair_superblock() -> Result<()> {
"--nr-data-blocks=20480",
&md
],
)?;
))?;
if !cfg!(feature = "rust_tests") {
assert_eq!(after.stderr.len(), 0);
}
@@ -196,14 +199,14 @@ fn missing_transaction_id() -> Result<()> {
let md = mk_valid_md(&mut td)?;
damage_superblock(&md)?;
let stderr = run_fail(
THIN_DUMP,
thin_dump_cmd(
args![
"--repair",
"--data-block-size=128",
"--nr-data-blocks=20480",
&md
],
)?;
))?;
assert!(stderr.contains("transaction id"));
Ok(())
}
@@ -214,14 +217,14 @@ fn missing_data_block_size() -> Result<()> {
let md = mk_valid_md(&mut td)?;
damage_superblock(&md)?;
let stderr = run_fail(
THIN_DUMP,
thin_dump_cmd(
args![
"--repair",
"--transaction-id=1",
"--nr-data-blocks=20480",
&md
],
)?;
))?;
assert!(stderr.contains("data block size"));
Ok(())
}
@@ -233,14 +236,14 @@ fn missing_nr_data_blocks() -> Result<()> {
let md = mk_valid_md(&mut td)?;
damage_superblock(&md)?;
let stderr = run_fail(
THIN_DUMP,
thin_dump_cmd(
args![
"--repair",
"--transaction-id=1",
"--data-block-size=128",
&md
],
)?;
))?;
assert!(stderr.contains("nr data blocks"));
Ok(())
}

18
tests/thin_metadata_pack.rs
View File

@@ -38,8 +38,12 @@ impl<'a> Program<'a> for ThinMetadataPack {
"thin_metadata_pack"
}
fn path() -> &'a std::ffi::OsStr {
THIN_METADATA_PACK.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
thin_metadata_pack_cmd(args)
}
fn usage() -> &'a str {
@@ -51,7 +55,7 @@ impl<'a> Program<'a> for ThinMetadataPack {
}
fn bad_option_hint(option: &str) -> String {
rust_msg::bad_option_hint(option)
msg::bad_option_hint(option)
}
}
@@ -61,21 +65,21 @@ impl<'a> InputProgram<'a> for ThinMetadataPack {
}
fn file_not_found() -> &'a str {
rust_msg::FILE_NOT_FOUND
msg::FILE_NOT_FOUND
}
fn missing_input_arg() -> &'a str {
rust_msg::MISSING_INPUT_ARG
msg::MISSING_INPUT_ARG
}
fn corrupted_input() -> &'a str {
rust_msg::BAD_SUPERBLOCK
msg::BAD_SUPERBLOCK
}
}
impl<'a> OutputProgram<'a> for ThinMetadataPack {
fn missing_output_arg() -> &'a str {
rust_msg::MISSING_OUTPUT_ARG
msg::MISSING_OUTPUT_ARG
}
}

27
tests/thin_metadata_unpack.rs
View File

@@ -40,8 +40,12 @@ impl<'a> Program<'a> for ThinMetadataUnpack {
"thin_metadata_pack"
}
fn path() -> &'a std::ffi::OsStr {
THIN_METADATA_UNPACK.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
thin_metadata_unpack_cmd(args)
}
fn usage() -> &'a str {
@@ -53,7 +57,7 @@ impl<'a> Program<'a> for ThinMetadataUnpack {
}
fn bad_option_hint(option: &str) -> String {
rust_msg::bad_option_hint(option)
msg::bad_option_hint(option)
}
}
@@ -63,11 +67,11 @@ impl<'a> InputProgram<'a> for ThinMetadataUnpack {
}
fn file_not_found() -> &'a str {
rust_msg::FILE_NOT_FOUND
msg::FILE_NOT_FOUND
}
fn missing_input_arg() -> &'a str {
rust_msg::MISSING_INPUT_ARG
msg::MISSING_INPUT_ARG
}
fn corrupted_input() -> &'a str {
@@ -77,7 +81,7 @@ impl<'a> InputProgram<'a> for ThinMetadataUnpack {
impl<'a> OutputProgram<'a> for ThinMetadataUnpack {
fn missing_output_arg() -> &'a str {
rust_msg::MISSING_OUTPUT_ARG
msg::MISSING_OUTPUT_ARG
}
}
@@ -102,14 +106,11 @@ fn end_to_end() -> Result<()> {
let mut td = TestDir::new()?;
let md_in = mk_valid_md(&mut td)?;
let md_out = mk_zeroed_md(&mut td)?;
run_ok(THIN_METADATA_PACK, args!["-i", &md_in, "-o", "meta.pack"])?;
run_ok(
THIN_METADATA_UNPACK,
args!["-i", "meta.pack", "-o", &md_out],
)?;
run_ok(thin_metadata_pack_cmd(args!["-i", &md_in, "-o", "meta.pack"]))?;
run_ok(thin_metadata_unpack_cmd(args!["-i", "meta.pack", "-o", &md_out]))?;
let dump1 = run_ok(THIN_DUMP, args![&md_in])?;
let dump2 = run_ok(THIN_DUMP, args![&md_out])?;
let dump1 = run_ok(thin_dump_cmd(args![&md_in]))?;
let dump2 = run_ok(thin_dump_cmd(args![&md_out]))?;
assert_eq!(dump1, dump2);
Ok(())
}

24
tests/thin_repair.rs
View File

@@ -33,8 +33,12 @@ impl<'a> Program<'a> for ThinRepair {
"thin_repair"
}
fn path() -> &'a std::ffi::OsStr {
THIN_REPAIR.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
thin_repair_cmd(args)
}
fn usage() -> &'a str {
@@ -108,7 +112,7 @@ fn dont_repair_xml() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_zeroed_md(&mut td)?;
let xml = mk_valid_xml(&mut td)?;
run_fail(THIN_REPAIR, args!["-i", &xml, "-o", &md])?;
run_fail(thin_repair_cmd(args!["-i", &xml, "-o", &md]))?;
Ok(())
}
@@ -121,9 +125,9 @@ fn override_thing(flag: &str, val: &str, pattern: &str) -> Result<()> {
let mut td = TestDir::new()?;
let md1 = mk_valid_md(&mut td)?;
let md2 = mk_zeroed_md(&mut td)?;
let output = run_ok_raw(THIN_REPAIR, args![flag, val, "-i", &md1, "-o", &md2])?;
let output = run_ok_raw(thin_repair_cmd(args![flag, val, "-i", &md1, "-o", &md2]))?;
assert_eq!(output.stderr.len(), 0);
let output = run_ok(THIN_DUMP, args![&md2])?;
let output = run_ok(thin_dump_cmd(args![&md2]))?;
assert!(output.contains(pattern));
Ok(())
}
@@ -151,14 +155,14 @@ fn override_nr_data_blocks() -> Result<()> {
fn superblock_succeeds() -> Result<()> {
let mut td = TestDir::new()?;
let md1 = mk_valid_md(&mut td)?;
let original = run_ok_raw(THIN_DUMP, args![&md1])?;
let original = run_ok_raw(thin_dump_cmd(args![&md1]))?;
if !cfg!(feature = "rust_tests") {
assert_eq!(original.stderr.len(), 0);
}
damage_superblock(&md1)?;
let md2 = mk_zeroed_md(&mut td)?;
run_ok(
THIN_REPAIR,
thin_repair_cmd(
args![
"--transaction-id=1",
"--data-block-size=128",
@@ -168,8 +172,8 @@ fn superblock_succeeds() -> Result<()> {
"-o",
&md2
],
)?;
let repaired = run_ok_raw(THIN_DUMP, args![&md2])?;
))?;
let repaired = run_ok_raw(thin_dump_cmd(args![&md2]))?;
if !cfg!(feature = "rust_tests") {
assert_eq!(repaired.stderr.len(), 0);
}
@@ -186,7 +190,7 @@ fn missing_thing(flag1: &str, flag2: &str, pattern: &str) -> Result<()> {
let md1 = mk_valid_md(&mut td)?;
damage_superblock(&md1)?;
let md2 = mk_zeroed_md(&mut td)?;
let stderr = run_fail(THIN_REPAIR, args![flag1, flag2, "-i", &md1, "-o", &md2])?;
let stderr = run_fail(thin_repair_cmd(args![flag1, flag2, "-i", &md1, "-o", &md2]))?;
assert!(stderr.contains(pattern));
Ok(())
}

14
tests/thin_restore.rs
View File

@@ -34,8 +34,12 @@ impl<'a> Program<'a> for ThinRestore {
"thin_restore"
}
fn path() -> &'a std::ffi::OsStr {
THIN_RESTORE.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
thin_restore_cmd(args)
}
fn usage() -> &'a str {
@@ -104,7 +108,7 @@ fn quiet_flag(flag: &str) -> Result<()> {
let xml = mk_valid_xml(&mut td)?;
let md = mk_zeroed_md(&mut td)?;
let output = run_ok_raw(THIN_RESTORE, args!["-i", &xml, "-o", &md, flag])?;
let output = run_ok_raw(thin_restore_cmd(args!["-i", &xml, "-o", &md, flag]))?;
assert_eq!(output.stdout.len(), 0);
assert_eq!(output.stderr.len(), 0);
@@ -130,9 +134,9 @@ fn override_something(flag: &str, value: &str, pattern: &str) -> Result<()> {
let xml = mk_valid_xml(&mut td)?;
let md = mk_zeroed_md(&mut td)?;
run_ok(THIN_RESTORE, args!["-i", &xml, "-o", &md, flag, value])?;
run_ok(thin_restore_cmd(args!["-i", &xml, "-o", &md, flag, value]))?;
let output = run_ok(THIN_DUMP, args![&md])?;
let output = run_ok(thin_dump_cmd(args![&md]))?;
assert!(output.contains(pattern));
Ok(())
}

23
tests/thin_rmap.rs
View File

@@ -29,8 +29,12 @@ impl<'a> Program<'a> for ThinRmap {
"thin_rmap"
}
fn path() -> &'a std::ffi::OsStr {
THIN_RMAP.as_ref()
fn cmd<I>(args: I) -> duct::Expression
where
I: IntoIterator,
I::Item: Into<std::ffi::OsString>,
{
thin_rmap_cmd(args)
}
fn usage() -> &'a str {
@@ -42,7 +46,7 @@ impl<'a> Program<'a> for ThinRmap {
}
fn bad_option_hint(option: &str) -> String {
cpp_msg::bad_option_hint(option)
msg::bad_option_hint(option)
}
}
@@ -58,7 +62,7 @@ test_rejects_bad_option!(ThinRmap);
fn valid_region_format_should_pass() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
run_ok(THIN_RMAP, args!["--region", "23..7890", &md])?;
run_ok(thin_rmap_cmd(args!["--region", "23..7890", &md]))?;
Ok(())
}
@@ -77,7 +81,7 @@ fn invalid_regions_should_fail() -> Result<()> {
for r in &invalid_regions {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
run_fail(THIN_RMAP, args![r, &md])?;
run_fail(thin_rmap_cmd(args![r, &md]))?;
}
Ok(())
}
@@ -86,10 +90,9 @@ fn invalid_regions_should_fail() -> Result<()> {
fn multiple_regions_should_pass() -> Result<()> {
let mut td = TestDir::new()?;
let md = mk_valid_md(&mut td)?;
run_ok(
THIN_RMAP,
args!["--region", "1..23", "--region", "45..78", &md],
)?;
run_ok(thin_rmap_cmd(args![
"--region", "1..23", "--region", "45..78", &md
]))?;
Ok(())
}
@@ -97,7 +100,7 @@ fn multiple_regions_should_pass() -> Result<()> {
fn junk_input() -> Result<()> {
let mut td = TestDir::new()?;
let xml = mk_valid_xml(&mut td)?;
run_fail(THIN_RMAP, args!["--region", "0..-1", &xml])?;
run_fail(thin_rmap_cmd(args!["--region", "0..-1", &xml]))?;
Ok(())
}