DevComp/zip-rs-wasm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #272 from kauhat/feature/end-to-end-all-methods

Browse source 
Test all compression methods in end to end test
This commit is contained in:
Alexander Zaitsev 2022-02-05 23:44:50 +03:00 • committed by GitHub
commit 0f5fa36025
Signed by: DevComp
GPG key ID: 4AEE18F83AFDEB23
1 changed files with 108 additions and 54 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

106
tests/end_to_end.rs
View file

@ -4,25 +4,30 @@ use std::io::prelude::*;
use std::io::{Cursor, Seek};
use std::iter::FromIterator;
use zip::write::FileOptions;
use zip::CompressionMethod;
use zip::{CompressionMethod, SUPPORTED_COMPRESSION_METHODS};
// This test asserts that after creating a zip file, then reading its contents back out,
// the extracted data will *always* be exactly the same as the original data.
#[test]
fn end_to_end() {
for &method in SUPPORTED_COMPRESSION_METHODS {
let file = &mut Cursor::new(Vec::new());
write_to_zip(file).expect("file written");
println!("Writing file with {} compression", method);
write_test_archive(file, method).expect("Couldn't write test zip archive");
check_zip_contents(file, ENTRY_NAME);
println!("Checking file contents");
check_archive_file(file, ENTRY_NAME, Some(method), LOREM_IPSUM);
}
}
// This test asserts that after copying a `ZipFile` to a new `ZipWriter`, then reading its
// contents back out, the extracted data will *always* be exactly the same as the original data.
#[test]
fn copy() {
for &method in SUPPORTED_COMPRESSION_METHODS {
let src_file = &mut Cursor::new(Vec::new());
write_to_zip(src_file).expect("file written");
write_test_archive(src_file, method).expect("Couldn't write to test file");
let mut tgt_file = &mut Cursor::new(Vec::new());
@ -31,69 +36,91 @@ fn copy() {
let mut zip = zip::ZipWriter::new(&mut tgt_file);
{
let file = src_archive.by_name(ENTRY_NAME).expect("file found");
zip.raw_copy_file(file).unwrap();
let file = src_archive
.by_name(ENTRY_NAME)
.expect("Missing expected file");
zip.raw_copy_file(file).expect("Couldn't copy file");
}
{
let file = src_archive.by_name(ENTRY_NAME).expect("file found");
zip.raw_copy_file_rename(file, COPY_ENTRY_NAME).unwrap();
let file = src_archive
.by_name(ENTRY_NAME)
.expect("Missing expected file");
zip.raw_copy_file_rename(file, COPY_ENTRY_NAME)
.expect("Couldn't copy and rename file");
}
}
let mut tgt_archive = zip::ZipArchive::new(tgt_file).unwrap();
check_zip_file_contents(&mut tgt_archive, ENTRY_NAME);
check_zip_file_contents(&mut tgt_archive, COPY_ENTRY_NAME);
check_archive_file_contents(&mut tgt_archive, ENTRY_NAME, LOREM_IPSUM);
check_archive_file_contents(&mut tgt_archive, COPY_ENTRY_NAME, LOREM_IPSUM);
}
}
// This test asserts that after appending to a `ZipWriter`, then reading its contents back out,
// both the prior data and the appended data will be exactly the same as their originals.
#[test]
fn append() {
for &method in SUPPORTED_COMPRESSION_METHODS {
let mut file = &mut Cursor::new(Vec::new());
write_to_zip(file).expect("file written");
write_test_archive(file, method).expect("Couldn't write to test file");
{
let mut zip = zip::ZipWriter::new_append(&mut file).unwrap();
zip.start_file(COPY_ENTRY_NAME, Default::default()).unwrap();
zip.start_file(
COPY_ENTRY_NAME,
FileOptions::default().compression_method(method),
)
.unwrap();
zip.write_all(LOREM_IPSUM).unwrap();
zip.finish().unwrap();
}
let mut zip = zip::ZipArchive::new(&mut file).unwrap();
check_zip_file_contents(&mut zip, ENTRY_NAME);
check_zip_file_contents(&mut zip, COPY_ENTRY_NAME);
check_archive_file_contents(&mut zip, ENTRY_NAME, LOREM_IPSUM);
check_archive_file_contents(&mut zip, COPY_ENTRY_NAME, LOREM_IPSUM);
}
}
fn write_to_zip(file: &mut Cursor<Vec<u8>>) -> zip::result::ZipResult<()> {
// Write a test zip archive to buffer.
fn write_test_archive(
file: &mut Cursor<Vec<u8>>,
method: CompressionMethod,
) -> zip::result::ZipResult<()> {
let mut zip = zip::ZipWriter::new(file);
zip.add_directory("test/", Default::default())?;
let options = FileOptions::default()
.compression_method(CompressionMethod::Stored)
.compression_method(method)
.unix_permissions(0o755);
zip.start_file("test/☃.txt", options)?;
zip.write_all(b"Hello, World!\n")?;
zip.start_file_with_extra_data("test_with_extra_data/🐢.txt", Default::default())?;
zip.start_file_with_extra_data("test_with_extra_data/🐢.txt", options)?;
zip.write_u16::<LittleEndian>(0xbeef)?;
zip.write_u16::<LittleEndian>(EXTRA_DATA.len() as u16)?;
zip.write_all(EXTRA_DATA)?;
zip.end_extra_data()?;
zip.write_all(b"Hello, World! Again.\n")?;
zip.start_file(ENTRY_NAME, Default::default())?;
zip.start_file(ENTRY_NAME, options)?;
zip.write_all(LOREM_IPSUM)?;
zip.finish()?;
Ok(())
}
fn read_zip<R: Read + Seek>(zip_file: R) -> zip::result::ZipResult<zip::ZipArchive<R>> {
// Load an archive from buffer and check for test data.
fn check_test_archive<R: Read + Seek>(zip_file: R) -> zip::result::ZipResult<zip::ZipArchive<R>> {
let mut archive = zip::ZipArchive::new(zip_file).unwrap();
// Check archive contains expected file names.
{
let expected_file_names = [
"test/",
"test/☃.txt",
@ -103,7 +130,9 @@ fn read_zip<R: Read + Seek>(zip_file: R) -> zip::result::ZipResult<zip::ZipArchi
let expected_file_names = HashSet::from_iter(expected_file_names.iter().copied());
let file_names = archive.file_names().collect::<HashSet<_>>();
assert_eq!(file_names, expected_file_names);
}
// Check an archive file for extra data field contents.
{
let file_with_extra_data = archive.by_name("test_with_extra_data/🐢.txt")?;
let mut extra_data = Vec::new();
@ -116,7 +145,8 @@ fn read_zip<R: Read + Seek>(zip_file: R) -> zip::result::ZipResult<zip::ZipArchi
Ok(archive)
}
fn read_zip_file<R: Read + Seek>(
// Read a file in the archive as a string.
fn read_archive_file<R: Read + Seek>(
archive: &mut zip::ZipArchive<R>,
name: &str,
) -> zip::result::ZipResult<String> {
@ -124,17 +154,41 @@ fn read_zip_file<R: Read + Seek>(
let mut contents = String::new();
file.read_to_string(&mut contents).unwrap();
Ok(contents)
}
fn check_zip_contents(zip_file: &mut Cursor<Vec<u8>>, name: &str) {
let mut archive = read_zip(zip_file).unwrap();
check_zip_file_contents(&mut archive, name);
// Check a file in the archive contains expected data and properties.
fn check_archive_file(
zip_file: &mut Cursor<Vec<u8>>,
name: &str,
expected_method: Option<CompressionMethod>,
expected_data: &[u8],
) {
let mut archive = check_test_archive(zip_file).unwrap();
if let Some(expected_method) = expected_method {
// Check the file's compression method.
let file = archive.by_name(name).unwrap();
let real_method = file.compression();
assert_eq!(
expected_method, real_method,
"File does not have expected compression method"
);
}
fn check_zip_file_contents<R: Read + Seek>(archive: &mut zip::ZipArchive<R>, name: &str) {
let file_contents: String = read_zip_file(archive, name).unwrap();
assert_eq!(file_contents.as_bytes(), LOREM_IPSUM);
check_archive_file_contents(&mut archive, name, expected_data);
}
// Check a file in the archive contains the given data.
fn check_archive_file_contents<R: Read + Seek>(
archive: &mut zip::ZipArchive<R>,
name: &str,
expected: &[u8],
) {
let file_contents: String = read_archive_file(archive, name).unwrap();
assert_eq!(file_contents.as_bytes(), expected);
}
const LOREM_IPSUM : &[u8] = b"Lorem ipsum dolor sit amet, consectetur adipiscing elit. In tellus elit, tristique vitae mattis egestas, ultricies vitae risus. Quisque sit amet quam ut urna aliquet