cyplo/bakare
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Extract common test functions

Browse source
This commit is contained in:
Cyryl Płotnicki 2019-09-07 14:19:03 +01:00
parent 8c43efcdce
commit 0a53f8c1f5
4 changed files with 87 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/lib.rs
View file

@ -4,5 +4,7 @@ pub mod repository;
pub mod restore;
pub mod source;
pub mod test;
mod index;
mod repository_item;

75
src/test/assertions.rs Normal file
View file

@ -0,0 +1,75 @@
use crate::error::BakareError;
use crate::repository::Repository;
use crate::{backup, restore};
use std::fs::File;
use std::io::Read;
use std::path::Path;
use tempfile::tempdir;
use walkdir::WalkDir;
pub fn assert_target_file_contents(restored_path: &Path, expected_contents: &str) -> Result<(), BakareError> {
let mut actual_contents = String::new();
assert!(restored_path.exists(), "Expected '{}' to be there", restored_path.display());
File::open(restored_path)?.read_to_string(&mut actual_contents)?;
assert_eq!(expected_contents, actual_contents);
Ok(())
}
pub fn assert_same_after_restore(source_path: &Path) -> Result<(), BakareError> {
let repository_path = tempdir()?.into_path();
let restore_target = tempdir()?.into_path();
assert_ne!(source_path, repository_path);
assert_ne!(repository_path, restore_target);
Repository::init(repository_path.as_path())?;
{
let mut backup_repository = Repository::open(repository_path.as_path())?;
let mut backup_engine = backup::Engine::new(source_path, &mut backup_repository);
backup_engine.backup()?;
}
{
let restore_repository = Repository::open(repository_path.as_path())?;
let restore_engine = restore::Engine::new(&restore_repository, &restore_target)?;
restore_engine.restore_all()?;
}
assert_directory_trees_have_same_contents(source_path, restore_target.as_path())?;
Ok(())
}
fn assert_directory_trees_have_same_contents(left: &Path, right: &Path) -> Result<(), BakareError> {
let left_files = get_sorted_files_recursively(left)?;
let right_files = get_sorted_files_recursively(right)?;
let pairs = left_files.iter().zip(right_files);
for (l, r) in pairs {
assert_eq!(l.file_name(), r.file_name());
let mut fl = File::open(l)?;
let mut fr = File::open(r)?;
let mut bl = vec![];
let mut br = vec![];
fl.read_to_end(&mut bl)?;
fr.read_to_end(&mut br)?;
assert_eq!(bl, br);
}
Ok(())
}
fn get_sorted_files_recursively(path: &Path) -> Result<Vec<Box<Path>>, BakareError> {
let walker = WalkDir::new(path).sort_by(|a, b| a.file_name().cmp(b.file_name()));
let mut result = vec![];
for maybe_entry in walker {
let entry = maybe_entry?;
if entry.path() == path {
continue;
}
if entry.path().is_file() {
result.push(Box::from(entry.path()));
}
}
Ok(result)
}

1
src/test/mod.rs Normal file
View file

@ -0,0 +1 @@
pub mod assertions;

88
tests/system_tests.rs
View file

@ -1,16 +1,13 @@
use bakare::backup;
use bakare::restore;
use bakare::source::TempSource;
use bakare::error::BakareError;
use bakare::repository::Repository;
use bakare::source::TempSource;
use bakare::test::assertions::{assert_same_after_restore, assert_target_file_contents};
use std::fs;
use std::fs::File;
use std::io::Read;
use std::path::Path;
use tempfile::tempdir;
use walkdir::WalkDir;
#[test]
fn restore_multiple_files() -> Result<(), BakareError> {
@ -60,20 +57,20 @@ fn restore_older_version_of_file() -> Result<(), BakareError> {
let repository_path = tempdir()?.into_path();
Repository::init(repository_path.as_path())?;
let relative_path_text = "some path";
let file_path = source.file_path(relative_path_text);
let source_file_relative_path = "some path";
let source_file_full_path = source.file_path(source_file_relative_path);
let old_contents = "some old contents";
{
let mut backup_repository = Repository::open(repository_path.as_path())?;
let mut backup_engine = backup::Engine::new(source.path(), &mut backup_repository);
source.write_text_to_file(relative_path_text, old_contents)?;
source.write_text_to_file(source_file_relative_path, old_contents)?;
backup_engine.backup()?;
}
let old_version = {
let reading_repository = Repository::open(repository_path.as_path())?;
let item = reading_repository.item_by_source_path(&file_path)?;
let item = reading_repository.item_by_source_path(&source_file_full_path)?;
assert!(item.is_some());
let item = item.unwrap();
item.version().clone()
@ -83,87 +80,20 @@ fn restore_older_version_of_file() -> Result<(), BakareError> {
let new_contents = "totally new contents";
let mut backup_repository = Repository::open(repository_path.as_path())?;
let mut backup_engine = backup::Engine::new(source.path(), &mut backup_repository);
source.write_text_to_file(relative_path_text, new_contents)?;
source.write_text_to_file(source_file_relative_path, new_contents)?;
backup_engine.backup()?;
}
let restore_repository = Repository::open(repository_path.as_path())?;
let restore_target = tempdir()?;
let restore_engine = restore::Engine::new(&restore_repository, &restore_target.path())?;
let old_item = restore_repository.item_by_source_path_and_version(&file_path, &old_version)?;
let old_item = restore_repository.item_by_source_path_and_version(&source_file_full_path, &old_version)?;
restore_engine.restore(&old_item.unwrap())?;
let source_file_full_path = source.file_path(relative_path_text);
let restored_file_path = restore_target.path().join(source_file_full_path.strip_prefix("/")?);
assert_target_file_contents(&restored_file_path, old_contents)
}
fn assert_target_file_contents(restored_path: &Path, expected_contents: &str) -> Result<(), BakareError> {
let mut actual_contents = String::new();
assert!(restored_path.exists(), "Expected '{}' to be there", restored_path.display());
File::open(restored_path)?.read_to_string(&mut actual_contents)?;
assert_eq!(expected_contents, actual_contents);
Ok(())
}
fn assert_same_after_restore(source_path: &Path) -> Result<(), BakareError> {
let repository_path = tempdir()?.into_path();
let restore_target = tempdir()?.into_path();
assert_ne!(source_path, repository_path);
assert_ne!(repository_path, restore_target);
Repository::init(repository_path.as_path())?;
{
let mut backup_repository = Repository::open(repository_path.as_path())?;
let mut backup_engine = backup::Engine::new(source_path, &mut backup_repository);
backup_engine.backup()?;
}
{
let restore_repository = Repository::open(repository_path.as_path())?;
let restore_engine = restore::Engine::new(&restore_repository, &restore_target)?;
restore_engine.restore_all()?;
}
assert_directory_trees_have_same_contents(source_path, restore_target.as_path())?;
Ok(())
}
fn assert_directory_trees_have_same_contents(left: &Path, right: &Path) -> Result<(), BakareError> {
let left_files = get_sorted_files_recursively(left)?;
let right_files = get_sorted_files_recursively(right)?;
let pairs = left_files.iter().zip(right_files);
for (l, r) in pairs {
assert_eq!(l.file_name(), r.file_name());
let mut fl = File::open(l)?;
let mut fr = File::open(r)?;
let mut bl = vec![];
let mut br = vec![];
fl.read_to_end(&mut bl)?;
fr.read_to_end(&mut br)?;
assert_eq!(bl, br);
}
Ok(())
}
fn get_sorted_files_recursively(path: &Path) -> Result<Vec<Box<Path>>, BakareError> {
let walker = WalkDir::new(path).sort_by(|a, b| a.file_name().cmp(b.file_name()));
let mut result = vec![];
for maybe_entry in walker {
let entry = maybe_entry?;
if entry.path() == path {
continue;
}
if entry.path().is_file() {
result.push(Box::from(entry.path()));
}
}
Ok(result)
}
// TODO: restore latest version by default
// TODO: deduplicate data
// TODO: test that index is stored separately from data