#![allow(dead_code)]
use std::convert::TryFrom;
use std::rc::Rc;
use std::str::FromStr;
use assert_fs::fixture::ChildPath;
use assert_fs::prelude::*;
use assert_fs::TempDir;
use rocfl::ocfl::{
ContentPath, ErrorCode, LogicalPath, ObjectValidationResult, ProblemLocation,
StorageValidationResult, ValidationError, ValidationResult, ValidationWarning, VersionNum,
WarnCode,
};
pub fn create_dirs(temp: &TempDir, path: &str) -> ChildPath {
let child = resolve_child(temp, path);
child.create_dir_all().unwrap();
child
}
pub fn create_file(temp: &TempDir, path: &str, content: &str) -> ChildPath {
let child = resolve_child(temp, path);
child.write_str(content).unwrap();
child
}
pub fn resolve_child(temp: &TempDir, path: &str) -> ChildPath {
let mut child: Option<ChildPath> = None;
for part in path.split('/') {
child = match child {
Some(child) => Some(child.child(part)),
None => Some(temp.child(part)),
};
}
child.unwrap()
}
pub fn lpath(path: &str) -> LogicalPath {
LogicalPath::try_from(path).unwrap()
}
pub fn lpath_rc(path: &str) -> Rc<LogicalPath> {
Rc::new(LogicalPath::try_from(path).unwrap())
}
pub fn cpath(path: &str) -> ContentPath {
ContentPath::try_from(path).unwrap()
}
pub fn cpath_rc(path: &str) -> Rc<ContentPath> {
Rc::new(ContentPath::try_from(path).unwrap())
}
pub fn version_error(num: &str, code: ErrorCode, text: &str) -> ValidationError {
ValidationError::new(
VersionNum::from_str(num).unwrap().into(),
code,
text.to_string(),
)
}
pub fn root_error(code: ErrorCode, text: &str) -> ValidationError {
ValidationError::new(ProblemLocation::ObjectRoot, code, text.to_string())
}
pub fn version_warning(num: &str, code: WarnCode, text: &str) -> ValidationWarning {
ValidationWarning::new(
VersionNum::from_str(num).unwrap().into(),
code,
text.to_string(),
)
}
pub fn root_warning(code: WarnCode, text: &str) -> ValidationWarning {
ValidationWarning::new(ProblemLocation::ObjectRoot, code, text.to_string())
}
pub fn has_errors(result: &ObjectValidationResult, expected_errors: &[ValidationError]) {
for expected in expected_errors {
assert!(
result.errors().contains(expected),
"Expected errors to contain {:?}. Found: {:?}",
expected,
result.errors()
);
}
assert_eq!(
expected_errors.len(),
result.errors().len(),
"Expected {} errors; found {}: {:?}",
expected_errors.len(),
result.errors().len(),
result.errors()
)
}
pub fn has_warnings(result: &ObjectValidationResult, expected_warnings: &[ValidationWarning]) {
for expected in expected_warnings {
assert!(
result.warnings().contains(expected),
"Expected warnings to contain {:?}. Found: {:?}",
expected,
result.warnings()
);
}
assert_eq!(
expected_warnings.len(),
result.warnings().len(),
"Expected {} warnings; found {}: {:?}",
expected_warnings.len(),
result.warnings().len(),
result.warnings()
)
}
pub fn has_errors_storage(result: &StorageValidationResult, expected_errors: &[ValidationError]) {
for expected in expected_errors {
assert!(
result.errors().contains(expected),
"Expected errors to contain {:?}. Found: {:?}",
expected,
result.errors()
);
}
assert_eq!(
expected_errors.len(),
result.errors().len(),
"Expected {} errors; found {}: {:?}",
expected_errors.len(),
result.errors().len(),
result.errors()
)
}
pub fn has_warnings_storage(
result: &StorageValidationResult,
expected_warnings: &[ValidationWarning],
) {
for expected in expected_warnings {
assert!(
result.warnings().contains(expected),
"Expected warnings to contain {:?}. Found: {:?}",
expected,
result.warnings()
);
}
assert_eq!(
expected_warnings.len(),
result.warnings().len(),
"Expected {} warnings; found {}: {:?}",
expected_warnings.len(),
result.warnings().len(),
result.warnings()
)
}
pub fn error_count(expected: usize, result: &ObjectValidationResult) {
assert_eq!(
expected,
result.errors().len(),
"Expected {} errors; found {}: {:?}",
expected,
result.errors().len(),
result.errors()
)
}
pub fn warning_count(expected: usize, result: &ObjectValidationResult) {
assert_eq!(
expected,
result.warnings().len(),
"Expected {} warnings; found {}: {:?}",
expected,
result.warnings().len(),
result.warnings()
)
}
pub fn no_warnings(result: &ObjectValidationResult) {
assert!(
result.warnings().is_empty(),
"Expected no warnings; found: {:?}",
result.warnings()
)
}
pub fn no_errors(result: &ObjectValidationResult) {
assert!(
result.errors().is_empty(),
"Expected no errors; found: {:?}",
result.errors()
)
}
pub fn no_warnings_storage(result: &StorageValidationResult) {
assert!(
result.warnings().is_empty(),
"Expected no warnings; found: {:?}",
result.warnings()
)
}
pub fn no_errors_storage(result: &StorageValidationResult) {
assert!(
result.errors().is_empty(),
"Expected no errors; found: {:?}",
result.errors()
)
}