From 6dcadff21d250eecbc68b7857059d67706d7b24b Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Mon, 24 Jan 2022 20:32:22 +0000 Subject: [PATCH 1/6] Add test changes from other branch --- tests/end_to_end.rs | 117 ++++++++++++++++++++++++++++++-------------- 1 file changed, 79 insertions(+), 38 deletions(-) diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index d0185f60..51daebad 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -4,87 +4,110 @@ use std::io::prelude::*; use std::io::{Cursor, Seek}; use std::iter::FromIterator; use zip::write::FileOptions; -use zip::CompressionMethod; +use zip::{CompressionMethod, SUPPORTED_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() { - let file = &mut Cursor::new(Vec::new()); + for &method in SUPPORTED_METHODS { + let file = &mut Cursor::new(Vec::new()); - write_to_zip(file).expect("file written"); + println!("Writing file with {} compression", method); + write_to_zip(file, method).expect("Couldn't write to test file"); - check_zip_contents(file, ENTRY_NAME); + println!("Checking file contents"); + check_zip_contents(file, ENTRY_NAME, Some(method)); + } } // 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() { - let src_file = &mut Cursor::new(Vec::new()); - write_to_zip(src_file).expect("file written"); + for &method in SUPPORTED_METHODS { + let src_file = &mut Cursor::new(Vec::new()); + write_to_zip(src_file, method).expect("Couldn't write to test file"); - let mut tgt_file = &mut Cursor::new(Vec::new()); - - { - let mut src_archive = zip::ZipArchive::new(src_file).unwrap(); - let mut zip = zip::ZipWriter::new(&mut tgt_file); + let mut tgt_file = &mut Cursor::new(Vec::new()); { - let file = src_archive.by_name(ENTRY_NAME).expect("file found"); - zip.raw_copy_file(file).unwrap(); + let mut src_archive = zip::ZipArchive::new(src_file).unwrap(); + let mut zip = zip::ZipWriter::new(&mut tgt_file); + + { + 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("Missing expected file"); + + zip.raw_copy_file_rename(file, COPY_ENTRY_NAME) + .expect("Couldn't copy and rename file"); + } } - { - let file = src_archive.by_name(ENTRY_NAME).expect("file found"); - zip.raw_copy_file_rename(file, COPY_ENTRY_NAME).unwrap(); - } + 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); } - - 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); } // 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() { - let mut file = &mut Cursor::new(Vec::new()); - write_to_zip(file).expect("file written"); + for &method in SUPPORTED_METHODS { + let mut file = &mut Cursor::new(Vec::new()); + write_to_zip(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.write_all(LOREM_IPSUM).unwrap(); - zip.finish().unwrap(); + { + let mut zip = zip::ZipWriter::new_append(&mut file).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); } - - 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); } -fn write_to_zip(file: &mut Cursor>) -> zip::result::ZipResult<()> { +fn write_to_zip( + file: &mut Cursor>, + 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::(0xbeef)?; zip.write_u16::(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()?; @@ -127,8 +150,26 @@ fn read_zip_file( Ok(contents) } -fn check_zip_contents(zip_file: &mut Cursor>, name: &str) { +fn check_zip_contents( + zip_file: &mut Cursor>, + name: &str, + expected_method: Option, +) { let mut archive = read_zip(zip_file).unwrap(); + + match expected_method { + Some(method) => { + let file = archive.by_name(name).unwrap(); + + assert_eq!( + method, + file.compression(), + "File does not have expected compression method" + ) + } + None => {} + } + check_zip_file_contents(&mut archive, name); } From 6711ac91a845d1d4b9482f63e4bc065f8d9e1edc Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Wed, 26 Jan 2022 22:21:17 +0000 Subject: [PATCH 2/6] Fix linter warnings --- tests/end_to_end.rs | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index 51daebad..4f938345 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -157,17 +157,14 @@ fn check_zip_contents( ) { let mut archive = read_zip(zip_file).unwrap(); - match expected_method { - Some(method) => { - let file = archive.by_name(name).unwrap(); + if let Some(expected_method) = expected_method { + let file = archive.by_name(name).unwrap(); + let real_method = file.compression(); - assert_eq!( - method, - file.compression(), - "File does not have expected compression method" - ) - } - None => {} + assert_eq!( + expected_method, real_method, + "File does not have expected compression method" + ); } check_zip_file_contents(&mut archive, name); From 161308c673009c5deaa9cceeb88bd8b592ae4495 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Wed, 26 Jan 2022 23:47:40 +0000 Subject: [PATCH 3/6] Add comments to test helpers --- tests/end_to_end.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index 4f938345..2e2c9793 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -85,6 +85,7 @@ fn append() { } } +// Write a test zip archive to buffer. fn write_to_zip( file: &mut Cursor>, method: CompressionMethod, @@ -114,6 +115,7 @@ fn write_to_zip( Ok(()) } +// Load an archive from buffer and check for expected test data. fn read_zip(zip_file: R) -> zip::result::ZipResult> { let mut archive = zip::ZipArchive::new(zip_file).unwrap(); @@ -139,6 +141,7 @@ fn read_zip(zip_file: R) -> zip::result::ZipResult( archive: &mut zip::ZipArchive, name: &str, @@ -150,14 +153,16 @@ fn read_zip_file( Ok(contents) } +// Check a file in the archive contains expected data. fn check_zip_contents( zip_file: &mut Cursor>, name: &str, expected_method: Option, ) { - let mut archive = read_zip(zip_file).unwrap(); + 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(); @@ -167,10 +172,11 @@ fn check_zip_contents( ); } - check_zip_file_contents(&mut archive, name); + check_test_file_contents(&mut archive, name); } -fn check_zip_file_contents(archive: &mut zip::ZipArchive, name: &str) { +// Check a file in the archive contains the lorem string. +fn check_test_file_contents(archive: &mut zip::ZipArchive, name: &str) { let file_contents: String = read_zip_file(archive, name).unwrap(); assert_eq!(file_contents.as_bytes(), LOREM_IPSUM); } From 4cb2067019115c30a6e45eed55e6e064fb033a1f Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Thu, 27 Jan 2022 00:12:17 +0000 Subject: [PATCH 4/6] Update test helper function names --- tests/end_to_end.rs | 51 +++++++++++++++++++++++++-------------------- 1 file changed, 28 insertions(+), 23 deletions(-) diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index 2e2c9793..5d880d17 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -14,10 +14,10 @@ fn end_to_end() { let file = &mut Cursor::new(Vec::new()); println!("Writing file with {} compression", method); - write_to_zip(file, method).expect("Couldn't write to test file"); + write_test_archive(file, method).expect("Couldn't write test zip archive"); println!("Checking file contents"); - check_zip_contents(file, ENTRY_NAME, Some(method)); + check_archive_file(file, ENTRY_NAME, Some(method)); } } @@ -27,7 +27,7 @@ fn end_to_end() { fn copy() { for &method in SUPPORTED_METHODS { let src_file = &mut Cursor::new(Vec::new()); - write_to_zip(src_file, method).expect("Couldn't write to test file"); + write_test_archive(src_file, method).expect("Couldn't write to test file"); let mut tgt_file = &mut Cursor::new(Vec::new()); @@ -55,8 +55,8 @@ fn copy() { 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_test_file_contents(&mut tgt_archive, ENTRY_NAME); + check_test_file_contents(&mut tgt_archive, COPY_ENTRY_NAME); } } @@ -66,7 +66,7 @@ fn copy() { fn append() { for &method in SUPPORTED_METHODS { let mut file = &mut Cursor::new(Vec::new()); - write_to_zip(file, method).expect("Couldn't write to test file"); + write_test_archive(file, method).expect("Couldn't write to test file"); { let mut zip = zip::ZipWriter::new_append(&mut file).unwrap(); @@ -80,13 +80,13 @@ fn append() { } 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_test_file_contents(&mut zip, ENTRY_NAME); + check_test_file_contents(&mut zip, COPY_ENTRY_NAME); } } // Write a test zip archive to buffer. -fn write_to_zip( +fn write_test_archive( file: &mut Cursor>, method: CompressionMethod, ) -> zip::result::ZipResult<()> { @@ -115,20 +115,24 @@ fn write_to_zip( Ok(()) } -// Load an archive from buffer and check for expected test data. -fn read_zip(zip_file: R) -> zip::result::ZipResult> { +// Load an archive from buffer and check for test data. +fn check_test_archive(zip_file: R) -> zip::result::ZipResult> { let mut archive = zip::ZipArchive::new(zip_file).unwrap(); - let expected_file_names = [ - "test/", - "test/☃.txt", - "test_with_extra_data/🐢.txt", - ENTRY_NAME, - ]; - let expected_file_names = HashSet::from_iter(expected_file_names.iter().copied()); - let file_names = archive.file_names().collect::>(); - assert_eq!(file_names, expected_file_names); + // Check archive contains expected files names. + { + let expected_file_names = [ + "test/", + "test/☃.txt", + "test_with_extra_data/🐢.txt", + ENTRY_NAME, + ]; + let expected_file_names = HashSet::from_iter(expected_file_names.iter().copied()); + let file_names = archive.file_names().collect::>(); + assert_eq!(file_names, expected_file_names); + } + // Check an archive file has expected extra field contents. { let file_with_extra_data = archive.by_name("test_with_extra_data/🐢.txt")?; let mut extra_data = Vec::new(); @@ -142,7 +146,7 @@ fn read_zip(zip_file: R) -> zip::result::ZipResult( +fn read_archive_file( archive: &mut zip::ZipArchive, name: &str, ) -> zip::result::ZipResult { @@ -150,11 +154,12 @@ fn read_zip_file( let mut contents = String::new(); file.read_to_string(&mut contents).unwrap(); + Ok(contents) } // Check a file in the archive contains expected data. -fn check_zip_contents( +fn check_archive_file( zip_file: &mut Cursor>, name: &str, expected_method: Option, @@ -177,7 +182,7 @@ fn check_zip_contents( // Check a file in the archive contains the lorem string. fn check_test_file_contents(archive: &mut zip::ZipArchive, name: &str) { - let file_contents: String = read_zip_file(archive, name).unwrap(); + let file_contents: String = read_archive_file(archive, name).unwrap(); assert_eq!(file_contents.as_bytes(), LOREM_IPSUM); } From 5aa0b601c900b8a11fb8ef39670fa58c0c4faec4 Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Thu, 27 Jan 2022 00:51:19 +0000 Subject: [PATCH 5/6] Add expected data param to test fn check_archive_file --- tests/end_to_end.rs | 29 +++++++++++++++++------------ 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index 5d880d17..38974a07 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -17,7 +17,7 @@ fn end_to_end() { write_test_archive(file, method).expect("Couldn't write test zip archive"); println!("Checking file contents"); - check_archive_file(file, ENTRY_NAME, Some(method)); + check_archive_file(file, ENTRY_NAME, Some(method), LOREM_IPSUM); } } @@ -55,8 +55,8 @@ fn copy() { let mut tgt_archive = zip::ZipArchive::new(tgt_file).unwrap(); - check_test_file_contents(&mut tgt_archive, ENTRY_NAME); - check_test_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); } } @@ -80,8 +80,8 @@ fn append() { } let mut zip = zip::ZipArchive::new(&mut file).unwrap(); - check_test_file_contents(&mut zip, ENTRY_NAME); - check_test_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); } } @@ -119,7 +119,7 @@ fn write_test_archive( fn check_test_archive(zip_file: R) -> zip::result::ZipResult> { let mut archive = zip::ZipArchive::new(zip_file).unwrap(); - // Check archive contains expected files names. + // Check archive contains expected file names. { let expected_file_names = [ "test/", @@ -132,7 +132,7 @@ fn check_test_archive(zip_file: R) -> zip::result::ZipResult( Ok(contents) } -// Check a file in the archive contains expected data. +// Check a file in the archive contains expected data and properties. fn check_archive_file( zip_file: &mut Cursor>, name: &str, expected_method: Option, + expected_data: &[u8], ) { let mut archive = check_test_archive(zip_file).unwrap(); @@ -177,13 +178,17 @@ fn check_archive_file( ); } - check_test_file_contents(&mut archive, name); + check_archive_file_contents(&mut archive, name, expected_data); } -// Check a file in the archive contains the lorem string. -fn check_test_file_contents(archive: &mut zip::ZipArchive, name: &str) { +// Check a file in the archive contains the given data. +fn check_archive_file_contents( + archive: &mut zip::ZipArchive, + name: &str, + expected: &[u8], +) { let file_contents: String = read_archive_file(archive, name).unwrap(); - assert_eq!(file_contents.as_bytes(), LOREM_IPSUM); + 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 From 0330f4707be73c2d19d5d6d8888d185b40334b8c Mon Sep 17 00:00:00 2001 From: Jack Fletcher Date: Sun, 30 Jan 2022 20:50:12 +0000 Subject: [PATCH 6/6] Update end to end methods import --- tests/end_to_end.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/end_to_end.rs b/tests/end_to_end.rs index 38974a07..25d0c54d 100644 --- a/tests/end_to_end.rs +++ b/tests/end_to_end.rs @@ -4,13 +4,13 @@ use std::io::prelude::*; use std::io::{Cursor, Seek}; use std::iter::FromIterator; use zip::write::FileOptions; -use zip::{CompressionMethod, SUPPORTED_METHODS}; +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_METHODS { + for &method in SUPPORTED_COMPRESSION_METHODS { let file = &mut Cursor::new(Vec::new()); println!("Writing file with {} compression", method); @@ -25,7 +25,7 @@ fn end_to_end() { // contents back out, the extracted data will *always* be exactly the same as the original data. #[test] fn copy() { - for &method in SUPPORTED_METHODS { + for &method in SUPPORTED_COMPRESSION_METHODS { let src_file = &mut Cursor::new(Vec::new()); write_test_archive(src_file, method).expect("Couldn't write to test file"); @@ -64,7 +64,7 @@ fn copy() { // both the prior data and the appended data will be exactly the same as their originals. #[test] fn append() { - for &method in SUPPORTED_METHODS { + for &method in SUPPORTED_COMPRESSION_METHODS { let mut file = &mut Cursor::new(Vec::new()); write_test_archive(file, method).expect("Couldn't write to test file");