+139

tests/bzip2.rs

reviewed

··· 1 1 + use assert_cmd::prelude::*; 2 2 + use assert_fs::prelude::*; 3 3 + use predicates::prelude::*; 4 4 + use std::{ 5 5 + fs::File, 6 6 + process::{Command, Stdio}, 7 7 + }; 8 8 + 9 9 + mod common; 10 10 + use common::*; 11 11 + 12 12 + mod bzip2 { 13 13 + use super::*; 14 14 + 15 15 + mod roundtrip { 16 16 + use super::*; 17 17 + 18 18 + /// Bzip2 roundtrip using files 19 19 + /// Compressing: input = test.txt, output = test.txt.bz2 20 20 + /// Extracting: input = test.txt.bz2, output = test.txt 21 21 + /// 22 22 + /// ``` bash 23 23 + /// cmprss bzip2 test.txt test.txt.bz2 24 24 + /// cmprss bzip2 --extract --ignore-pipes test.txt.bz2 25 25 + /// ``` 26 26 + #[test] 27 27 + fn explicit() -> Result<(), Box<dyn std::error::Error>> { 28 28 + let file = create_test_file("test.txt", "garbage data for testing")?; 29 29 + let working_dir = create_working_dir()?; 30 30 + let archive = working_dir.child("test.txt.bz2"); 31 31 + archive.assert(predicate::path::missing()); 32 32 + 33 33 + let mut compress = Command::cargo_bin("cmprss")?; 34 34 + compress 35 35 + .current_dir(&working_dir) 36 36 + .arg("bzip2") 37 37 + .arg(file.path()) 38 38 + .arg(archive.path()); 39 39 + compress.assert().success(); 40 40 + archive.assert(predicate::path::is_file()); 41 41 + 42 42 + let mut extract = Command::cargo_bin("cmprss")?; 43 43 + extract 44 44 + .current_dir(&working_dir) 45 45 + .arg("bzip2") 46 46 + .arg("--ignore-pipes") 47 47 + .arg("--extract") 48 48 + .arg(archive.path()); 49 49 + extract.assert().success(); 50 50 + 51 51 + // Assert the files are identical 52 52 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 53 53 + 54 54 + Ok(()) 55 55 + } 56 56 + 57 57 + /// Bzip2 roundtrip using stdin 58 58 + /// Compressing: input = stdin, output = test.txt.bz2 59 59 + /// Extracting: input = stdin(test.txt.bz2), output = test.txt 60 60 + /// 61 61 + /// ``` bash 62 62 + /// cat test.txt | cmprss bzip2 test.txt.bz2 63 63 + /// cat test.txt.bz2 | cmprss bzip2 --extract out.txt 64 64 + /// ``` 65 65 + #[test] 66 66 + fn stdin() -> Result<(), Box<dyn std::error::Error>> { 67 67 + let file = create_test_file("test.txt", "garbage data for testing")?; 68 68 + let working_dir = create_working_dir()?; 69 69 + let archive = working_dir.child("test.txt.bz2"); 70 70 + archive.assert(predicate::path::missing()); 71 71 + 72 72 + // Pipe file to stdin 73 73 + let mut compress = Command::cargo_bin("cmprss")?; 74 74 + compress 75 75 + .current_dir(&working_dir) 76 76 + .arg("bzip2") 77 77 + .arg("test.txt.bz2") 78 78 + .stdin(Stdio::from(File::open(file.path())?)); 79 79 + compress.assert().success(); 80 80 + archive.assert(predicate::path::is_file()); 81 81 + 82 82 + let mut extract = Command::cargo_bin("cmprss")?; 83 83 + extract 84 84 + .current_dir(&working_dir) 85 85 + .arg("bzip2") 86 86 + .stdin(Stdio::from(File::open(archive.path())?)) 87 87 + .arg("--extract") 88 88 + .arg("out.txt"); 89 89 + extract.assert().success(); 90 90 + 91 91 + // Assert the files are identical 92 92 + assert_files_equal(file.path(), &working_dir.child("out.txt")); 93 93 + 94 94 + Ok(()) 95 95 + } 96 96 + 97 97 + /// Bzip2 roundtrip using stdout 98 98 + /// Compressing: input = test.txt, output = stdout 99 99 + /// Extracting: input = test.txt.bz2, output = stdout 100 100 + /// 101 101 + /// ``` bash 102 102 + /// cmprss bzip2 test.txt > test.txt.bz2 103 103 + /// cmprss bzip2 --extract test.txt.bz2 > out.txt 104 104 + /// ``` 105 105 + #[test] 106 106 + fn stdout() -> Result<(), Box<dyn std::error::Error>> { 107 107 + let file = create_test_file("test.txt", "garbage data for testing")?; 108 108 + let working_dir = create_working_dir()?; 109 109 + let archive = working_dir.child("test.txt.bz2"); 110 110 + archive.assert(predicate::path::missing()); 111 111 + 112 112 + // Compress file to stdout 113 113 + let mut compress = Command::cargo_bin("cmprss")?; 114 114 + compress 115 115 + .current_dir(&working_dir) 116 116 + .arg("bzip2") 117 117 + .arg(file.path()) 118 118 + .stdout(Stdio::from(File::create(archive.path())?)); 119 119 + compress.assert().success(); 120 120 + archive.assert(predicate::path::is_file()); 121 121 + 122 122 + // Extract file to stdout 123 123 + let mut extract = Command::cargo_bin("cmprss")?; 124 124 + extract 125 125 + .current_dir(&working_dir) 126 126 + .arg("bzip2") 127 127 + .arg("--ignore-stdin") 128 128 + .arg("--extract") 129 129 + .arg(archive.path()) 130 130 + .arg("out.txt"); 131 131 + extract.assert().success(); 132 132 + 133 133 + // Assert the files are identical 134 134 + assert_files_equal(file.path(), &working_dir.child("out.txt")); 135 135 + 136 136 + Ok(()) 137 137 + } 138 138 + } 139 139 + }

-1386

tests/cli.rs

reviewed

··· 1 1 - mod cli { 2 2 - use assert_cmd::prelude::*; 3 3 - use assert_fs::prelude::*; 4 4 - use predicates::prelude::*; 5 5 - use std::{ 6 6 - fs::File, 7 7 - path::PathBuf, 8 8 - process::{Command, Stdio}, 9 9 - }; 10 10 - 11 11 - /// Tar roundtrip with a single file 12 12 - /// 13 13 - /// ``` bash 14 14 - /// cmprss tar test.txt archive.tar 15 15 - /// cmprss tar --extract archive.tar . 16 16 - /// ``` 17 17 - #[test] 18 18 - fn tar_roundtrip_explicit() -> Result<(), Box<dyn std::error::Error>> { 19 19 - let file = assert_fs::NamedTempFile::new("test.txt")?; 20 20 - file.write_str("garbage data for testing")?; 21 21 - let working_dir = assert_fs::TempDir::new()?; 22 22 - let archive = working_dir.child("archive.tar"); 23 23 - archive.assert(predicate::path::missing()); 24 24 - 25 25 - let mut compress = Command::cargo_bin("cmprss")?; 26 26 - compress.arg("tar").arg(file.path()).arg(archive.path()); 27 27 - compress.assert().success(); 28 28 - archive.assert(predicate::path::is_file()); 29 29 - 30 30 - let mut extract = Command::cargo_bin("cmprss")?; 31 31 - extract 32 32 - .arg("tar") 33 33 - .arg("--extract") 34 34 - .arg(archive.path()) 35 35 - .arg(working_dir.path()); 36 36 - extract.assert().success(); 37 37 - 38 38 - // Assert the files are identical 39 39 - working_dir 40 40 - .child("test.txt") 41 41 - .assert(predicate::path::eq_file(file.path())); 42 42 - 43 43 - Ok(()) 44 44 - } 45 45 - 46 46 - /// Tar roundtrip with multiple files 47 47 - /// 48 48 - /// ``` bash 49 49 - /// cmprss tar test.txt test2.txt archive.tar 50 50 - /// cmprss tar --extract archive.tar . 51 51 - /// ``` 52 52 - #[test] 53 53 - fn tar_roundtrip_explicit_two() -> Result<(), Box<dyn std::error::Error>> { 54 54 - let file = assert_fs::NamedTempFile::new("test.txt")?; 55 55 - file.write_str("garbage data for testing")?; 56 56 - let file2 = assert_fs::NamedTempFile::new("test2.txt")?; 57 57 - file2.write_str("more garbage data for testing")?; 58 58 - let working_dir = assert_fs::TempDir::new()?; 59 59 - let archive = working_dir.child("archive.tar"); 60 60 - archive.assert(predicate::path::missing()); 61 61 - 62 62 - let mut compress = Command::cargo_bin("cmprss")?; 63 63 - compress 64 64 - .arg("tar") 65 65 - .arg(file.path()) 66 66 - .arg(file2.path()) 67 67 - .arg(archive.path()); 68 68 - compress.assert().success(); 69 69 - archive.assert(predicate::path::is_file()); 70 70 - 71 71 - let mut extract = Command::cargo_bin("cmprss")?; 72 72 - extract 73 73 - .arg("tar") 74 74 - .arg("--extract") 75 75 - .arg(archive.path()) 76 76 - .arg(working_dir.path()); 77 77 - extract.assert().success(); 78 78 - 79 79 - // Assert the files are identical 80 80 - working_dir 81 81 - .child("test.txt") 82 82 - .assert(predicate::path::eq_file(file.path())); 83 83 - working_dir 84 84 - .child("test2.txt") 85 85 - .assert(predicate::path::eq_file(file2.path())); 86 86 - 87 87 - Ok(()) 88 88 - } 89 89 - 90 90 - /// Tar roundtrip with a single file inferring output filename 91 91 - /// Compressing: output = './test.txt.tar' 92 92 - /// Extracting: output = '.' 93 93 - /// 94 94 - /// ``` bash 95 95 - /// cmprss tar test.txt 96 96 - /// cmprss tar --extract test.txt.tar 97 97 - /// ``` 98 98 - #[test] 99 99 - fn tar_roundtrip_implicit() -> Result<(), Box<dyn std::error::Error>> { 100 100 - let file = assert_fs::NamedTempFile::new("test.txt")?; 101 101 - file.write_str("garbage data for testing")?; 102 102 - let working_dir = assert_fs::TempDir::new()?.into_persistent(); 103 103 - let archive = working_dir.child("test.txt.tar"); 104 104 - archive.assert(predicate::path::missing()); 105 105 - 106 106 - let mut compress = Command::cargo_bin("cmprss")?; 107 107 - compress 108 108 - .current_dir(&working_dir) 109 109 - .arg("tar") 110 110 - .arg("--ignore-pipes") 111 111 - .arg(file.path()); 112 112 - compress.assert().success(); 113 113 - archive.assert(predicate::path::is_file()); 114 114 - 115 115 - let mut extract = Command::cargo_bin("cmprss")?; 116 116 - extract 117 117 - .current_dir(&working_dir) 118 118 - .arg("tar") 119 119 - .arg("--ignore-pipes") 120 120 - .arg("--extract") 121 121 - .arg(archive.path()); 122 122 - extract.assert().success(); 123 123 - 124 124 - // Assert the files are identical 125 125 - working_dir 126 126 - .child("test.txt") 127 127 - .assert(predicate::path::eq_file(file.path())); 128 128 - 129 129 - Ok(()) 130 130 - } 131 131 - 132 132 - /// Tar roundtrip with multiple files inferring output 133 133 - /// Uses the first file's name to generate the output filename 134 134 - /// Compressing: output = './test.txt.tar' 135 135 - /// Extracting: output = '.' 136 136 - /// 137 137 - /// ``` bash 138 138 - /// cmprss tar test.txt test2.txt 139 139 - /// cmprss tar test.txt.tar 140 140 - /// ``` 141 141 - #[test] 142 142 - fn tar_roundtrip_implicit_two() -> Result<(), Box<dyn std::error::Error>> { 143 143 - let file = assert_fs::NamedTempFile::new("test.txt")?; 144 144 - file.write_str("garbage data for testing")?; 145 145 - let file2 = assert_fs::NamedTempFile::new("test2.txt")?; 146 146 - file2.write_str("more garbage data for testing")?; 147 147 - let working_dir = assert_fs::TempDir::new()?.into_persistent(); 148 148 - let archive = working_dir.child("test.txt.tar"); 149 149 - archive.assert(predicate::path::missing()); 150 150 - 151 151 - let mut compress = Command::cargo_bin("cmprss")?; 152 152 - compress 153 153 - .current_dir(&working_dir) 154 154 - .arg("tar") 155 155 - .arg("--ignore-pipes") 156 156 - .arg(file.path()) 157 157 - .arg(file2.path()); 158 158 - compress.assert().success(); 159 159 - archive.assert(predicate::path::is_file()); 160 160 - 161 161 - let mut extract = Command::cargo_bin("cmprss")?; 162 162 - extract 163 163 - .current_dir(&working_dir) 164 164 - .arg("--ignore-pipes") 165 165 - .arg(archive.path()); 166 166 - extract.assert().success(); 167 167 - 168 168 - // Assert the files are identical 169 169 - working_dir 170 170 - .child("test.txt") 171 171 - .assert(predicate::path::eq_file(file.path())); 172 172 - working_dir 173 173 - .child("test2.txt") 174 174 - .assert(predicate::path::eq_file(file2.path())); 175 175 - 176 176 - Ok(()) 177 177 - } 178 178 - 179 179 - /// Gzip roundtrip using stdin 180 180 - /// Compressing: input = stdin, output = test.txt.gz 181 181 - /// Extracting: input = test.txt.gz, output = test.txt 182 182 - /// 183 183 - /// ``` bash 184 184 - /// cat test.txt | cmprss gzip test.txt.gz 185 185 - /// cmprss gzip --ignore-pipes --extract test.txt.gz 186 186 - /// ``` 187 187 - #[test] 188 188 - fn gzip_roundtrip_stdin() -> Result<(), Box<dyn std::error::Error>> { 189 189 - let file = assert_fs::NamedTempFile::new("test.txt")?; 190 190 - file.write_str("garbage data for testing")?; 191 191 - let working_dir = assert_fs::TempDir::new()?; 192 192 - let archive = working_dir.child("test.txt.gz"); 193 193 - archive.assert(predicate::path::missing()); 194 194 - 195 195 - // Pipe file to stdin 196 196 - let mut compress = Command::cargo_bin("cmprss")?; 197 197 - compress 198 198 - .current_dir(&working_dir) 199 199 - .arg("gzip") 200 200 - .arg("test.txt.gz") 201 201 - .stdin(Stdio::from(File::open(file.path())?)); 202 202 - compress.assert().success(); 203 203 - archive.assert(predicate::path::is_file()); 204 204 - 205 205 - let mut extract = Command::cargo_bin("cmprss")?; 206 206 - extract 207 207 - .current_dir(&working_dir) 208 208 - .arg("gzip") 209 209 - .arg("--ignore-pipes") 210 210 - .arg("--extract") 211 211 - .arg(archive.path()); 212 212 - extract.assert().success(); 213 213 - 214 214 - // Assert the files are identical 215 215 - working_dir 216 216 - .child("test.txt") 217 217 - .assert(predicate::path::eq_file(file.path())); 218 218 - 219 219 - Ok(()) 220 220 - } 221 221 - 222 222 - /// Gzip roundtrip using filename inference 223 223 - /// Compressing: input = stdin, output = default filename (archive.gz) 224 224 - /// Extracting: input = archive.gz, output = default filename (archive) 225 225 - /// 226 226 - /// ``` bash 227 227 - /// cat test.txt | cmprss gzip 228 228 - /// cmprss gzip --ignore-pipes --extract archive.gz 229 229 - /// ``` 230 230 - #[test] 231 231 - fn gzip_roundtrip_inferred_output_filenames() -> Result<(), Box<dyn std::error::Error>> { 232 232 - let file = assert_fs::NamedTempFile::new("test.txt")?; 233 233 - file.write_str("garbage data for testing")?; 234 234 - let working_dir = assert_fs::TempDir::new()?; 235 235 - let archive = working_dir.child("archive.gz"); // default filename 236 236 - archive.assert(predicate::path::missing()); 237 237 - 238 238 - // Pipe file to stdin 239 239 - let mut compress = Command::cargo_bin("cmprss")?; 240 240 - compress 241 241 - .current_dir(&working_dir) 242 242 - .arg("gzip") 243 243 - .arg("--ignore-stdout") 244 244 - .stdin(Stdio::from(File::open(file.path())?)); 245 245 - compress.assert().success(); 246 246 - archive.assert(predicate::path::is_file()); 247 247 - 248 248 - let mut extract = Command::cargo_bin("cmprss")?; 249 249 - extract 250 250 - .current_dir(&working_dir) 251 251 - .arg("gzip") 252 252 - .arg("--ignore-pipes") 253 253 - .arg("--extract") 254 254 - .arg(archive.path()); 255 255 - extract.assert().success(); 256 256 - 257 257 - // Assert the files are identical 258 258 - working_dir 259 259 - .child("archive") 260 260 - .assert(predicate::path::eq_file(file.path())); 261 261 - 262 262 - Ok(()) 263 263 - } 264 264 - 265 265 - /// Xz roundtrip using files 266 266 - /// Compressing: input = test.txt, output = test.txt.xz 267 267 - /// Extracting: input = test.txt.xz, output = test.txt 268 268 - /// 269 269 - /// ``` bash 270 270 - /// cmprss xz test.txt test.txt.xz 271 271 - /// cmprss xz --extract --ignore-pipes test.txt.xz 272 272 - /// ``` 273 273 - #[test] 274 274 - fn xz_roundtrip_explicit() -> Result<(), Box<dyn std::error::Error>> { 275 275 - let file = assert_fs::NamedTempFile::new("test.txt")?; 276 276 - file.write_str("garbage data for testing")?; 277 277 - let working_dir = assert_fs::TempDir::new()?; 278 278 - let archive = working_dir.child("test.txt.xz"); 279 279 - archive.assert(predicate::path::missing()); 280 280 - 281 281 - let mut compress = Command::cargo_bin("cmprss")?; 282 282 - compress 283 283 - .current_dir(&working_dir) 284 284 - .arg("xz") 285 285 - .arg(file.path()) 286 286 - .arg(archive.path()); 287 287 - compress.assert().success(); 288 288 - archive.assert(predicate::path::is_file()); 289 289 - 290 290 - let mut extract = Command::cargo_bin("cmprss")?; 291 291 - extract 292 292 - .current_dir(&working_dir) 293 293 - .arg("xz") 294 294 - .arg("--ignore-pipes") 295 295 - .arg("--extract") 296 296 - .arg(archive.path()); 297 297 - extract.assert().success(); 298 298 - 299 299 - // Assert the files are identical 300 300 - working_dir 301 301 - .child("test.txt") 302 302 - .assert(predicate::path::eq_file(file.path())); 303 303 - 304 304 - Ok(()) 305 305 - } 306 306 - 307 307 - /// Xz roundtrip using stdin 308 308 - /// Compressing: input = stdin, output = test.txt.xz 309 309 - /// Extracting: input = stdin(test.txt.xz), output = test.txt 310 310 - /// 311 311 - /// ``` bash 312 312 - /// cat test.txt | cmprss xz test.txt.xz 313 313 - /// cat test.txt.xz | cmprss xz --extract out.txt 314 314 - /// ``` 315 315 - #[test] 316 316 - fn xz_roundtrip_stdin() -> Result<(), Box<dyn std::error::Error>> { 317 317 - let file = assert_fs::NamedTempFile::new("test.txt")?; 318 318 - file.write_str("garbage data for testing")?; 319 319 - let working_dir = assert_fs::TempDir::new()?; 320 320 - let archive = working_dir.child("test.txt.xz"); 321 321 - archive.assert(predicate::path::missing()); 322 322 - 323 323 - // Pipe file to stdin 324 324 - let mut compress = Command::cargo_bin("cmprss")?; 325 325 - compress 326 326 - .current_dir(&working_dir) 327 327 - .arg("xz") 328 328 - .arg("test.txt.xz") 329 329 - .stdin(Stdio::from(File::open(file.path())?)); 330 330 - compress.assert().success(); 331 331 - archive.assert(predicate::path::is_file()); 332 332 - 333 333 - let mut extract = Command::cargo_bin("cmprss")?; 334 334 - extract 335 335 - .current_dir(&working_dir) 336 336 - .arg("xz") 337 337 - .stdin(Stdio::from(File::open(archive.path())?)) 338 338 - .arg("--extract") 339 339 - .arg("out.txt"); 340 340 - extract.assert().success(); 341 341 - 342 342 - // Assert the files are identical 343 343 - working_dir 344 344 - .child("out.txt") 345 345 - .assert(predicate::path::eq_file(file.path())); 346 346 - 347 347 - Ok(()) 348 348 - } 349 349 - 350 350 - /// Xz roundtrip using stdout 351 351 - /// Compressing: input = test.txt, output = stdout 352 352 - /// Extracting: input = test.txt.xz, output = stdout 353 353 - /// 354 354 - /// ``` bash 355 355 - /// cmprss xz test.txt > test.txt.xz 356 356 - /// cmprss xz --extract test.txt.xz > out.txt 357 357 - /// ``` 358 358 - #[test] 359 359 - fn xz_roundtrip_stdout() -> Result<(), Box<dyn std::error::Error>> { 360 360 - let file = assert_fs::NamedTempFile::new("test.txt")?; 361 361 - file.write_str("garbage data for testing")?; 362 362 - let working_dir = assert_fs::TempDir::new()?; 363 363 - let archive = working_dir.child("test.txt.xz"); 364 364 - archive.assert(predicate::path::missing()); 365 365 - 366 366 - // Compress file to stdout 367 367 - let mut compress = Command::cargo_bin("cmprss")?; 368 368 - compress 369 369 - .current_dir(&working_dir) 370 370 - .arg("xz") 371 371 - .arg(file.path()) 372 372 - .stdout(Stdio::from(File::create(archive.path())?)); 373 373 - compress.assert().success(); 374 374 - archive.assert(predicate::path::is_file()); 375 375 - 376 376 - // Extract file to stdout 377 377 - let mut extract = Command::cargo_bin("cmprss")?; 378 378 - extract 379 379 - .current_dir(&working_dir) 380 380 - .arg("xz") 381 381 - .arg("--ignore-stdin") 382 382 - .arg("--extract") 383 383 - .arg(archive.path()) 384 384 - .arg("out.txt"); 385 385 - // TODO: This fails, but manual testing shows it works fine 386 386 - //.stdout(Stdio::from(File::create("out.txt")?)); 387 387 - extract.assert().success(); 388 388 - 389 389 - // Assert the files are identical 390 390 - working_dir 391 391 - .child("out.txt") 392 392 - .assert(predicate::path::eq_file(file.path())); 393 393 - 394 394 - Ok(()) 395 395 - } 396 396 - 397 397 - /// Bzip2 roundtrip using files 398 398 - /// Compressing: input = test.txt, output = test.txt.bz2 399 399 - /// Extracting: input = test.txt.bz2, output = test.txt 400 400 - /// 401 401 - /// ``` bash 402 402 - /// cmprss bzip2 test.txt test.txt.bz2 403 403 - /// cmprss bzip2 --extract --ignore-pipes test.txt.bz2 404 404 - /// ``` 405 405 - #[test] 406 406 - fn bzip2_roundtrip_explicit() -> Result<(), Box<dyn std::error::Error>> { 407 407 - let file = assert_fs::NamedTempFile::new("test.txt")?; 408 408 - file.write_str("garbage data for testing")?; 409 409 - 410 410 - let working_dir = assert_fs::TempDir::new()?; 411 411 - let archive = working_dir.child("test.txt.bz2"); 412 412 - archive.assert(predicate::path::missing()); 413 413 - 414 414 - let mut compress = Command::cargo_bin("cmprss")?; 415 415 - compress 416 416 - .current_dir(&working_dir) 417 417 - .arg("bzip2") 418 418 - .arg(file.path()) 419 419 - .arg(archive.path()); 420 420 - compress.assert().success(); 421 421 - archive.assert(predicate::path::is_file()); 422 422 - 423 423 - let mut extract = Command::cargo_bin("cmprss")?; 424 424 - extract 425 425 - .current_dir(&working_dir) 426 426 - .arg("bzip2") 427 427 - .arg("--ignore-pipes") 428 428 - .arg("--extract") 429 429 - .arg(archive.path()); 430 430 - extract.assert().success(); 431 431 - 432 432 - // Assert the files are identical 433 433 - working_dir 434 434 - .child("test.txt") 435 435 - .assert(predicate::path::eq_file(file.path())); 436 436 - 437 437 - Ok(()) 438 438 - } 439 439 - 440 440 - /// Bzip2 roundtrip using stdin 441 441 - /// Compressing: input = stdin, output = test.txt.bz2 442 442 - /// Extracting: input = stdin(test.txt.bz2), output = test.txt 443 443 - /// 444 444 - /// ``` bash 445 445 - /// cat test.txt | cmprss bzip2 test.txt.bz2 446 446 - /// cat test.txt.bz2 | cmprss bzip2 --extract out.txt 447 447 - /// ``` 448 448 - #[test] 449 449 - fn bzip2_roundtrip_stdin() -> Result<(), Box<dyn std::error::Error>> { 450 450 - let file = assert_fs::NamedTempFile::new("test.txt")?; 451 451 - file.write_str("garbage data for testing")?; 452 452 - 453 453 - let working_dir = assert_fs::TempDir::new()?; 454 454 - let archive = working_dir.child("test.txt.bz2"); 455 455 - archive.assert(predicate::path::missing()); 456 456 - 457 457 - // Pipe file to stdin 458 458 - let mut compress = Command::cargo_bin("cmprss")?; 459 459 - compress 460 460 - .current_dir(&working_dir) 461 461 - .arg("bzip2") 462 462 - .arg("test.txt.bz2") 463 463 - .stdin(Stdio::from(File::open(file.path())?)); 464 464 - compress.assert().success(); 465 465 - archive.assert(predicate::path::is_file()); 466 466 - 467 467 - let mut extract = Command::cargo_bin("cmprss")?; 468 468 - extract 469 469 - .current_dir(&working_dir) 470 470 - .arg("bzip2") 471 471 - .stdin(Stdio::from(File::open(archive.path())?)) 472 472 - .arg("--extract") 473 473 - .arg("out.txt"); 474 474 - extract.assert().success(); 475 475 - 476 476 - // Assert the files are identical 477 477 - working_dir 478 478 - .child("out.txt") 479 479 - .assert(predicate::path::eq_file(file.path())); 480 480 - 481 481 - Ok(()) 482 482 - } 483 483 - 484 484 - /// Bzip2 roundtrip using stdout 485 485 - /// Compressing: input = test.txt, output = stdout 486 486 - /// Extracting: input = test.txt.bz2, output = stdout 487 487 - /// 488 488 - /// ``` bash 489 489 - /// cmprss bzip2 test.txt > test.txt.bz2 490 490 - /// cmprss bzip2 --extract test.txt.bz2 > out.txt 491 491 - /// ``` 492 492 - #[test] 493 493 - fn bzip2_roundtrip_stdout() -> Result<(), Box<dyn std::error::Error>> { 494 494 - let file = assert_fs::NamedTempFile::new("test.txt")?; 495 495 - file.write_str("garbage data for testing")?; 496 496 - 497 497 - let working_dir = assert_fs::TempDir::new()?; 498 498 - let archive = working_dir.child("test.txt.bz2"); 499 499 - archive.assert(predicate::path::missing()); 500 500 - 501 501 - // Compress file to stdout 502 502 - let mut compress = Command::cargo_bin("cmprss")?; 503 503 - compress 504 504 - .current_dir(&working_dir) 505 505 - .arg("bzip2") 506 506 - .arg(file.path()) 507 507 - .stdout(Stdio::from(File::create(archive.path())?)); 508 508 - compress.assert().success(); 509 509 - archive.assert(predicate::path::is_file()); 510 510 - 511 511 - // Extract file to stdout 512 512 - let mut extract = Command::cargo_bin("cmprss")?; 513 513 - extract 514 514 - .current_dir(&working_dir) 515 515 - .arg("bzip2") 516 516 - .arg("--ignore-stdin") 517 517 - .arg("--extract") 518 518 - .arg(archive.path()) 519 519 - .arg("out.txt"); 520 520 - // TODO: This fails, but manual testing shows it works fine 521 521 - //.stdout(Stdio::from(File::create("out.txt")?)); 522 522 - extract.assert().success(); 523 523 - 524 524 - // Assert the files are identical 525 525 - working_dir 526 526 - .child("out.txt") 527 527 - .assert(predicate::path::eq_file(file.path())); 528 528 - 529 529 - Ok(()) 530 530 - } 531 531 - 532 532 - /// Zip roundtrip with a single file 533 533 - /// 534 534 - /// ``` bash 535 535 - /// cmprss zip test.txt archive.zip 536 536 - /// cmprss zip --extract archive.zip . 537 537 - /// ``` 538 538 - #[test] 539 539 - fn zip_roundtrip_explicit() -> Result<(), Box<dyn std::error::Error>> { 540 540 - let file = assert_fs::NamedTempFile::new("test.txt")?; 541 541 - file.write_str("garbage data for testing")?; 542 542 - let working_dir = assert_fs::TempDir::new()?; 543 543 - let archive = working_dir.child("archive.zip"); 544 544 - archive.assert(predicate::path::missing()); 545 545 - 546 546 - let mut compress = Command::cargo_bin("cmprss")?; 547 547 - compress.arg("zip").arg(file.path()).arg(archive.path()); 548 548 - compress.assert().success(); 549 549 - archive.assert(predicate::path::is_file()); 550 550 - 551 551 - let mut extract = Command::cargo_bin("cmprss")?; 552 552 - extract 553 553 - .arg("zip") 554 554 - .arg("--extract") 555 555 - .arg(archive.path()) 556 556 - .arg(working_dir.path()); 557 557 - extract.assert().success(); 558 558 - 559 559 - // Assert the files are identical 560 560 - working_dir 561 561 - .child("test.txt") 562 562 - .assert(predicate::path::eq_file(file.path())); 563 563 - 564 564 - Ok(()) 565 565 - } 566 566 - 567 567 - /// Zip roundtrip with multiple files 568 568 - /// 569 569 - /// ``` bash 570 570 - /// cmprss zip test.txt test2.txt archive.zip 571 571 - /// cmprss zip --extract archive.zip . 572 572 - /// ``` 573 573 - #[test] 574 574 - fn zip_roundtrip_explicit_two() -> Result<(), Box<dyn std::error::Error>> { 575 575 - let file = assert_fs::NamedTempFile::new("test.txt")?; 576 576 - file.write_str("garbage data for testing")?; 577 577 - let file2 = assert_fs::NamedTempFile::new("test2.txt")?; 578 578 - file2.write_str("more garbage data for testing")?; 579 579 - let working_dir = assert_fs::TempDir::new()?; 580 580 - let archive = working_dir.child("archive.zip"); 581 581 - archive.assert(predicate::path::missing()); 582 582 - 583 583 - let mut compress = Command::cargo_bin("cmprss")?; 584 584 - compress 585 585 - .arg("zip") 586 586 - .arg(file.path()) 587 587 - .arg(file2.path()) 588 588 - .arg(archive.path()); 589 589 - compress.assert().success(); 590 590 - archive.assert(predicate::path::is_file()); 591 591 - 592 592 - let mut extract = Command::cargo_bin("cmprss")?; 593 593 - extract 594 594 - .arg("zip") 595 595 - .arg("--extract") 596 596 - .arg(archive.path()) 597 597 - .arg(working_dir.path()); 598 598 - extract.assert().success(); 599 599 - 600 600 - // Assert the files are identical 601 601 - working_dir 602 602 - .child("test.txt") 603 603 - .assert(predicate::path::eq_file(file.path())); 604 604 - working_dir 605 605 - .child("test2.txt") 606 606 - .assert(predicate::path::eq_file(file2.path())); 607 607 - 608 608 - Ok(()) 609 609 - } 610 610 - 611 611 - /// Zip roundtrip with a directory 612 612 - /// 613 613 - /// ``` bash 614 614 - /// cmprss zip directory archive.zip 615 615 - /// cmprss zip --extract archive.zip output_dir 616 616 - /// ``` 617 617 - #[test] 618 618 - fn zip_roundtrip_directory() -> Result<(), Box<dyn std::error::Error>> { 619 619 - let dir = assert_fs::TempDir::new()?; 620 620 - let file = dir.child("test.txt"); 621 621 - file.write_str("garbage data for testing")?; 622 622 - let file2 = dir.child("test2.txt"); 623 623 - file2.write_str("more garbage data for testing")?; 624 624 - 625 625 - let working_dir = assert_fs::TempDir::new()?; 626 626 - let archive = working_dir.child("archive.zip"); 627 627 - archive.assert(predicate::path::missing()); 628 628 - 629 629 - let mut compress = Command::cargo_bin("cmprss")?; 630 630 - compress.arg("zip").arg(dir.path()).arg(archive.path()); 631 631 - compress.assert().success(); 632 632 - archive.assert(predicate::path::is_file()); 633 633 - 634 634 - let extract_dir = working_dir.child("output"); 635 635 - std::fs::create_dir_all(extract_dir.path())?; 636 636 - 637 637 - let mut extract = Command::cargo_bin("cmprss")?; 638 638 - extract 639 639 - .arg("zip") 640 640 - .arg("--extract") 641 641 - .arg(archive.path()) 642 642 - .arg(extract_dir.path()); 643 643 - extract.assert().success(); 644 644 - 645 645 - // Assert the files are identical 646 646 - // Since the archive stores the entire directory, the extracted file is contained in the directory 647 647 - let dir_name: PathBuf = dir.path().file_name().unwrap().into(); 648 648 - extract_dir 649 649 - .child(&dir_name) 650 650 - .child("test.txt") 651 651 - .assert(predicate::path::eq_file(file.path())); 652 652 - extract_dir 653 653 - .child(&dir_name) 654 654 - .child("test2.txt") 655 655 - .assert(predicate::path::eq_file(file2.path())); 656 656 - 657 657 - Ok(()) 658 658 - } 659 659 - 660 660 - /// Magic roundtrip using stdin 661 661 - /// Compressing: input = stdin, output = test.txt.gz 662 662 - /// Extracting: input = test.txt.gz, output = test.txt 663 663 - /// 664 664 - /// ``` bash 665 665 - /// cat test.txt | cmprss test.txt.gz 666 666 - /// cmprss gz --extract test.txt.gz out.txt 667 667 - /// ``` 668 668 - #[test] 669 669 - fn magic_roundtrip_stdin() -> Result<(), Box<dyn std::error::Error>> { 670 670 - let file = assert_fs::NamedTempFile::new("test.txt")?; 671 671 - file.write_str("garbage data for testing")?; 672 672 - 673 673 - let working_dir = assert_fs::TempDir::new()?; 674 674 - let archive = working_dir.child("test.txt.gz"); 675 675 - archive.assert(predicate::path::missing()); 676 676 - 677 677 - // Pipe file to stdin 678 678 - let mut compress = Command::cargo_bin("cmprss")?; 679 679 - compress 680 680 - .current_dir(&working_dir) 681 681 - .arg("--ignore-stdout") 682 682 - .arg("test.txt.gz") 683 683 - .stdin(Stdio::from(File::open(file.path())?)); 684 684 - compress.assert().success(); 685 685 - archive.assert(predicate::path::is_file()); 686 686 - 687 687 - let mut extract = Command::cargo_bin("cmprss")?; 688 688 - extract 689 689 - .current_dir(&working_dir) 690 690 - .arg("gz") 691 691 - .arg("--ignore-pipes") 692 692 - .arg("--extract") 693 693 - .arg("test.txt.gz"); 694 694 - extract.assert().success(); 695 695 - 696 696 - // Assert the files are identical 697 697 - working_dir 698 698 - .child("test.txt") 699 699 - .assert(predicate::path::eq_file(file.path())); 700 700 - 701 701 - Ok(()) 702 702 - } 703 703 - 704 704 - /// Magic roundtrip using files 705 705 - /// Compressing: input = test.txt, output = test.txt.gz 706 706 - /// Extracting: input = test.txt.gz, output = stdout 707 707 - /// 708 708 - /// ``` bash 709 709 - /// cmprss test.txt test.txt.gz 710 710 - /// cmprss test.txt.gz out.txt 711 711 - /// ``` 712 712 - #[test] 713 713 - fn magic_roundtrip_files() -> Result<(), Box<dyn std::error::Error>> { 714 714 - let file = assert_fs::NamedTempFile::new("test.txt")?; 715 715 - file.write_str("garbage data for testing")?; 716 716 - 717 717 - let working_dir = assert_fs::TempDir::new()?; 718 718 - let archive = working_dir.child("test.txt.gz"); 719 719 - archive.assert(predicate::path::missing()); 720 720 - 721 721 - // Compress file to an archive 722 722 - let mut compress = Command::cargo_bin("cmprss")?; 723 723 - compress 724 724 - .current_dir(&working_dir) 725 725 - .arg("--ignore-pipes") 726 726 - .arg(file.path()) 727 727 - .arg("test.txt.gz"); 728 728 - compress.assert().success(); 729 729 - archive.assert(predicate::path::is_file()); 730 730 - 731 731 - // Extract file to given file 732 732 - let mut extract = Command::cargo_bin("cmprss")?; 733 733 - extract 734 734 - .current_dir(&working_dir) 735 735 - .arg("--ignore-pipes") 736 736 - .arg("test.txt.gz") 737 737 - .arg("out.txt"); 738 738 - extract.assert().success(); 739 739 - 740 740 - // Assert the files are identical 741 741 - working_dir 742 742 - .child("out.txt") 743 743 - .assert(predicate::path::eq_file(file.path())); 744 744 - 745 745 - Ok(()) 746 746 - } 747 747 - 748 748 - /// Magic roundtrip using stdout decompression 749 749 - /// Compressing: input = test.txt, output = test.txt.gz 750 750 - /// Extracting: input = test.txt.gz, output = stdout 751 751 - /// 752 752 - /// ``` bash 753 753 - /// cmprss test.txt test.txt.gz 754 754 - /// cmprss test.txt.gz > out.txt 755 755 - /// ``` 756 756 - #[test] 757 757 - fn magic_roundtrip_stdout_decompression() -> Result<(), Box<dyn std::error::Error>> { 758 758 - let file = assert_fs::NamedTempFile::new("test.txt")?; 759 759 - file.write_str("garbage data for testing")?; 760 760 - 761 761 - let working_dir = assert_fs::TempDir::new()?; 762 762 - let archive = working_dir.child("test.txt.gz"); 763 763 - archive.assert(predicate::path::missing()); 764 764 - 765 765 - let out_file = working_dir.child("out.txt"); 766 766 - 767 767 - // Compress file to an archive 768 768 - let mut compress = Command::cargo_bin("cmprss")?; 769 769 - compress 770 770 - .current_dir(&working_dir) 771 771 - .arg("--ignore-pipes") 772 772 - .arg(file.path()) 773 773 - .arg("test.txt.gz"); 774 774 - compress.assert().success(); 775 775 - archive.assert(predicate::path::is_file()); 776 776 - 777 777 - // Extract file to stdout 778 778 - let mut extract = Command::cargo_bin("cmprss")?; 779 779 - extract 780 780 - .current_dir(&working_dir) 781 781 - .arg("--ignore-stdin") 782 782 - .arg("test.txt.gz") 783 783 - .stdout(Stdio::from(File::create(&out_file)?)); 784 784 - extract.assert().success(); 785 785 - 786 786 - // Assert the files are identical 787 787 - out_file.assert(predicate::path::eq_file(file.path())); 788 788 - Ok(()) 789 789 - } 790 790 - 791 791 - /// Magic roundtrip using stdin compression 792 792 - /// Compressing: input = stdin, output = test.txt.gz 793 793 - /// Extracting: input = test.txt.gz, output = test.txt 794 794 - /// 795 795 - /// ``` bash 796 796 - /// cat test.txt | cmprss test.txt.gz 797 797 - /// cmprss test.txt.gz out.txt 798 798 - /// ``` 799 799 - #[test] 800 800 - fn magic_roundtrip_stdin_compression() -> Result<(), Box<dyn std::error::Error>> { 801 801 - let file = assert_fs::NamedTempFile::new("test.txt")?; 802 802 - file.write_str("garbage data for testing")?; 803 803 - 804 804 - let working_dir = assert_fs::TempDir::new()?; 805 805 - let archive = working_dir.child("test.txt.gz"); 806 806 - archive.assert(predicate::path::missing()); 807 807 - 808 808 - let out_file = working_dir.child("out.txt"); 809 809 - 810 810 - // Compress stdin to an archive 811 811 - let mut compress = Command::cargo_bin("cmprss")?; 812 812 - compress 813 813 - .current_dir(&working_dir) 814 814 - .arg("--ignore-stdout") 815 815 - .arg("test.txt.gz") 816 816 - .stdin(Stdio::from(File::open(file.path())?)); 817 817 - compress.assert().success(); 818 818 - archive.assert(predicate::path::is_file()); 819 819 - 820 820 - // Extract file to given file 821 821 - let mut extract = Command::cargo_bin("cmprss")?; 822 822 - extract 823 823 - .current_dir(&working_dir) 824 824 - .arg("--ignore-pipes") 825 825 - .arg("test.txt.gz") 826 826 - .arg(out_file.path()); 827 827 - extract.assert().success(); 828 828 - 829 829 - // Assert the files are identical 830 830 - out_file.assert(predicate::path::eq_file(file.path())); 831 831 - 832 832 - Ok(()) 833 833 - } 834 834 - 835 835 - /// Magic roundtrip using default filenames 836 836 - /// Compressing: input = test.txt, output = test.txt.gz 837 837 - /// Extracting: input = test.txt.gz, output = <default> 838 838 - /// 839 839 - /// ``` bash 840 840 - /// cmprss test.txt test.txt.gz 841 841 - /// cmprss test.txt.gz 842 842 - /// ``` 843 843 - #[test] 844 844 - fn magic_roundtrip_default_filenames() -> Result<(), Box<dyn std::error::Error>> { 845 845 - let file = assert_fs::NamedTempFile::new("test.txt")?; 846 846 - file.write_str("garbage data for testing")?; 847 847 - 848 848 - let working_dir = assert_fs::TempDir::new()?; 849 849 - let archive = working_dir.child("test.txt.gz"); 850 850 - archive.assert(predicate::path::missing()); 851 851 - 852 852 - // Compress file to an archive 853 853 - let mut compress = Command::cargo_bin("cmprss")?; 854 854 - compress 855 855 - .current_dir(&working_dir) 856 856 - .arg("--ignore-pipes") 857 857 - .arg(file.path()) 858 858 - .arg("test.txt.gz"); 859 859 - compress.assert().success(); 860 860 - archive.assert(predicate::path::is_file()); 861 861 - 862 862 - // Extract file to default filename 863 863 - let mut extract = Command::cargo_bin("cmprss")?; 864 864 - extract 865 865 - .current_dir(&working_dir) 866 866 - .arg("--ignore-pipes") 867 867 - .arg("test.txt.gz"); 868 868 - extract.assert().success(); 869 869 - 870 870 - // Assert the files are identical 871 871 - working_dir 872 872 - .child("test.txt") 873 873 - .assert(predicate::path::eq_file(file.path())); 874 874 - 875 875 - Ok(()) 876 876 - } 877 877 - 878 878 - /// Magic roundtrip using multiple files with tar 879 879 - /// Compressing: input = test.txt/test2.txt, output = archive.tar 880 880 - /// Extracting: input = archive.tar, output = <default> 881 881 - /// 882 882 - /// ``` bash 883 883 - /// cmprss test.txt test2.txt archive.tar 884 884 - /// cmprss archive.tar 885 885 - /// ``` 886 886 - #[test] 887 887 - fn magic_roundtrip_multiple_files_tar() -> Result<(), Box<dyn std::error::Error>> { 888 888 - let file = assert_fs::NamedTempFile::new("test.txt")?; 889 889 - file.write_str("garbage data for testing")?; 890 890 - let file2 = assert_fs::NamedTempFile::new("test2.txt")?; 891 891 - file2.write_str("more garbage data for testing")?; 892 892 - 893 893 - let working_dir = assert_fs::TempDir::new()?; 894 894 - let archive = working_dir.child("archive.tar"); 895 895 - archive.assert(predicate::path::missing()); 896 896 - 897 897 - // Compress files to an archive 898 898 - let mut compress = Command::cargo_bin("cmprss")?; 899 899 - compress 900 900 - .current_dir(&working_dir) 901 901 - .arg("--ignore-pipes") 902 902 - .arg(file.path()) 903 903 - .arg(file2.path()) 904 904 - .arg("archive.tar"); 905 905 - compress.assert().success(); 906 906 - archive.assert(predicate::path::is_file()); 907 907 - 908 908 - // Extract file to default filename 909 909 - let mut extract = Command::cargo_bin("cmprss")?; 910 910 - extract 911 911 - .current_dir(&working_dir) 912 912 - .arg("--ignore-pipes") 913 913 - .arg("archive.tar"); 914 914 - extract.assert().success(); 915 915 - 916 916 - // Assert the files are identical 917 917 - working_dir 918 918 - .child("test.txt") 919 919 - .assert(predicate::path::eq_file(file.path())); 920 920 - working_dir 921 921 - .child("test2.txt") 922 922 - .assert(predicate::path::eq_file(file2.path())); 923 923 - 924 924 - Ok(()) 925 925 - } 926 926 - 927 927 - /// Magic roundtrip with tar.gz 928 928 - /// Infer things as much as possible 929 929 - /// Compressing: input = test.txt + test2.txt, output = test.tar.gz 930 930 - /// Extracting: input = test.tar.gz, output = test.txt + test2.txt 931 931 - /// 932 932 - /// ``` bash 933 933 - /// cmprss test.txt test2.txt archive.tar 934 934 - /// cmprss archive.tar archive.tar.gz 935 935 - /// cmprss archive.tar.gz archive.tar 936 936 - /// cmprss archive.tar 937 937 - /// ``` 938 938 - #[test] 939 939 - fn magic_roundtrip_tar_gz() -> Result<(), Box<dyn std::error::Error>> { 940 940 - let file = assert_fs::NamedTempFile::new("test.txt")?; 941 941 - file.write_str("garbage data for testing")?; 942 942 - let file2 = assert_fs::NamedTempFile::new("test2.txt")?; 943 943 - file2.write_str("more garbage data for testing")?; 944 944 - 945 945 - let working_dir = assert_fs::TempDir::new()?; 946 946 - let archive = working_dir.child("archive.tar"); 947 947 - archive.assert(predicate::path::missing()); 948 948 - let archive2 = working_dir.child("archive.tar.gz"); 949 949 - archive2.assert(predicate::path::missing()); 950 950 - 951 951 - let extract_dir = assert_fs::TempDir::new()?; 952 952 - 953 953 - // Compress files to an archive 954 954 - let mut compress = Command::cargo_bin("cmprss")?; 955 955 - compress 956 956 - .current_dir(&working_dir) 957 957 - .arg("--ignore-pipes") 958 958 - .arg(file.path()) 959 959 - .arg(file2.path()) 960 960 - .arg("archive.tar"); 961 961 - compress.assert().success(); 962 962 - archive.assert(predicate::path::is_file()); 963 963 - 964 964 - // Compress tar to an archive 965 965 - let mut compress2 = Command::cargo_bin("cmprss")?; 966 966 - compress2 967 967 - .current_dir(&working_dir) 968 968 - .arg("--ignore-pipes") 969 969 - .arg("archive.tar") 970 970 - .arg("archive.tar.gz"); 971 971 - compress2.assert().success(); 972 972 - archive2.assert(predicate::path::is_file()); 973 973 - 974 974 - // Extract file to default filename 975 975 - let mut extract = Command::cargo_bin("cmprss")?; 976 976 - extract 977 977 - .current_dir(&extract_dir) 978 978 - .arg("--ignore-pipes") 979 979 - .arg(archive2.path()) 980 980 - .arg("archive.tar"); 981 981 - extract.assert().success(); 982 982 - 983 983 - // Extract file to default filename 984 984 - let mut extract2 = Command::cargo_bin("cmprss")?; 985 985 - extract2 986 986 - .current_dir(&extract_dir) 987 987 - .arg("--ignore-pipes") 988 988 - .arg("archive.tar"); 989 989 - extract2.assert().success(); 990 990 - 991 991 - // Assert the files are identical 992 992 - extract_dir 993 993 - .child("test.txt") 994 994 - .assert(predicate::path::eq_file(file.path())); 995 995 - extract_dir 996 996 - .child("test2.txt") 997 997 - .assert(predicate::path::eq_file(file2.path())); 998 998 - 999 999 - Ok(()) 1000 1000 - } 1001 1001 - 1002 1002 - /// Magic roundtrip with tar.gz using pipes 1003 1003 - /// Infer things as much as possible 1004 1004 - /// Compressing: input = test.txt + test2.txt, output = test.tar.gz 1005 1005 - /// Extracting: input = test.tar.gz, output = test.txt + test2.txt 1006 1006 - /// 1007 1007 - /// ``` bash 1008 1008 - /// cmprss tar test.txt test2.txt | cmprss gzip | cmprss gzip --extract | cmprss tar --extract 1009 1009 - /// ``` 1010 1010 - #[test] 1011 1011 - fn magic_roundtrip_tar_gz_pipes() -> Result<(), Box<dyn std::error::Error>> { 1012 1012 - let file = assert_fs::NamedTempFile::new("test.txt")?; 1013 1013 - file.write_str("garbage data for testing")?; 1014 1014 - let file2 = assert_fs::NamedTempFile::new("test2.txt")?; 1015 1015 - file2.write_str("more garbage data for testing")?; 1016 1016 - 1017 1017 - let working_dir = assert_fs::TempDir::new()?; 1018 1018 - let tee1 = working_dir.child("tee1"); 1019 1019 - let tee2 = working_dir.child("tee2"); 1020 1020 - let tee3 = working_dir.child("tee3"); 1021 1021 - 1022 1022 - let extract_dir = assert_fs::TempDir::new()?; 1023 1023 - 1024 1024 - let mut compress = Command::cargo_bin("cmprss")?; 1025 1025 - compress 1026 1026 - .current_dir(&working_dir) 1027 1027 - .arg("tar") 1028 1028 - .arg("--ignore-stdin") 1029 1029 - .arg(file.path()) 1030 1030 - .arg(file2.path()) 1031 1031 - .stdout(Stdio::from(File::create(tee1.path())?)); 1032 1032 - compress.assert().success(); 1033 1033 - tee1.assert(predicate::path::is_file()); 1034 1034 - 1035 1035 - let mut compress2 = Command::cargo_bin("cmprss")?; 1036 1036 - compress2 1037 1037 - .current_dir(&working_dir) 1038 1038 - .arg("gzip") 1039 1039 - .stdin(Stdio::from(File::open(tee1.path())?)) 1040 1040 - .stdout(Stdio::from(File::create(tee2.path())?)); 1041 1041 - compress2.assert().success(); 1042 1042 - tee2.assert(predicate::path::is_file()); 1043 1043 - 1044 1044 - let mut extract = Command::cargo_bin("cmprss")?; 1045 1045 - extract 1046 1046 - .current_dir(&working_dir) 1047 1047 - .arg("gzip") 1048 1048 - .arg("--extract") 1049 1049 - .stdin(Stdio::from(File::open(tee2.path())?)) 1050 1050 - .stdout(Stdio::from(File::create(tee3.path())?)); 1051 1051 - extract.assert().success(); 1052 1052 - tee3.assert(predicate::path::is_file()); 1053 1053 - 1054 1054 - // Extract file to default filename 1055 1055 - let mut extract2 = Command::cargo_bin("cmprss")?; 1056 1056 - extract2 1057 1057 - .current_dir(&extract_dir) 1058 1058 - .arg("tar") 1059 1059 - .arg("--ignore-stdout") 1060 1060 - .arg("--extract") 1061 1061 - .stdin(Stdio::from(File::open(tee3.path())?)); 1062 1062 - extract2.assert().success(); 1063 1063 - 1064 1064 - // Assert the files are identical 1065 1065 - extract_dir 1066 1066 - .child("test.txt") 1067 1067 - .assert(predicate::path::eq_file(file.path())); 1068 1068 - extract_dir 1069 1069 - .child("test2.txt") 1070 1070 - .assert(predicate::path::eq_file(file2.path())); 1071 1071 - 1072 1072 - Ok(()) 1073 1073 - } 1074 1074 - 1075 1075 - /// Zstd roundtrip using explicit filenames 1076 1076 - /// Compressing: input = test.txt, output = test.txt.zst 1077 1077 - /// Extracting: input = test.txt.zst, output = test.txt 1078 1078 - /// 1079 1079 - /// ``` bash 1080 1080 - /// cmprss zstd test.txt test.txt.zst 1081 1081 - /// cmprss zstd --extract --ignore-pipes test.txt.zst 1082 1082 - /// ``` 1083 1083 - #[test] 1084 1084 - fn zstd_roundtrip_explicit() -> Result<(), Box<dyn std::error::Error>> { 1085 1085 - let file = assert_fs::NamedTempFile::new("test.txt")?; 1086 1086 - file.write_str("garbage data for testing")?; 1087 1087 - 1088 1088 - let working_dir = assert_fs::TempDir::new()?; 1089 1089 - let archive = working_dir.child("test.txt.zst"); 1090 1090 - archive.assert(predicate::path::missing()); 1091 1091 - 1092 1092 - let mut compress = Command::cargo_bin("cmprss")?; 1093 1093 - compress 1094 1094 - .current_dir(&working_dir) 1095 1095 - .arg("zstd") 1096 1096 - .arg(file.path()) 1097 1097 - .arg(archive.path()); 1098 1098 - compress.assert().success(); 1099 1099 - archive.assert(predicate::path::is_file()); 1100 1100 - 1101 1101 - let mut extract = Command::cargo_bin("cmprss")?; 1102 1102 - extract 1103 1103 - .current_dir(&working_dir) 1104 1104 - .arg("zstd") 1105 1105 - .arg("--ignore-pipes") 1106 1106 - .arg("--extract") 1107 1107 - .arg(archive.path()); 1108 1108 - extract.assert().success(); 1109 1109 - 1110 1110 - // Assert the files are identical 1111 1111 - working_dir 1112 1112 - .child("test.txt") 1113 1113 - .assert(predicate::path::eq_file(file.path())); 1114 1114 - 1115 1115 - Ok(()) 1116 1116 - } 1117 1117 - 1118 1118 - /// Zstd roundtrip using stdin 1119 1119 - /// Compressing: input = stdin, output = test.txt.zst 1120 1120 - /// Extracting: input = stdin(test.txt.zst), output = test.txt 1121 1121 - /// 1122 1122 - /// ``` bash 1123 1123 - /// cat test.txt | cmprss zstd test.txt.zst 1124 1124 - /// cat test.txt.zst | cmprss zstd --extract out.txt 1125 1125 - /// ``` 1126 1126 - #[test] 1127 1127 - fn zstd_roundtrip_stdin() -> Result<(), Box<dyn std::error::Error>> { 1128 1128 - let file = assert_fs::NamedTempFile::new("test.txt")?; 1129 1129 - file.write_str("garbage data for testing")?; 1130 1130 - 1131 1131 - let working_dir = assert_fs::TempDir::new()?; 1132 1132 - let archive = working_dir.child("test.txt.zst"); 1133 1133 - archive.assert(predicate::path::missing()); 1134 1134 - 1135 1135 - // Pipe file to stdin 1136 1136 - let mut compress = Command::cargo_bin("cmprss")?; 1137 1137 - compress 1138 1138 - .current_dir(&working_dir) 1139 1139 - .arg("zstd") 1140 1140 - .arg("test.txt.zst") 1141 1141 - .stdin(Stdio::from(File::open(file.path())?)); 1142 1142 - compress.assert().success(); 1143 1143 - archive.assert(predicate::path::is_file()); 1144 1144 - 1145 1145 - let mut extract = Command::cargo_bin("cmprss")?; 1146 1146 - extract 1147 1147 - .current_dir(&working_dir) 1148 1148 - .arg("zstd") 1149 1149 - .stdin(Stdio::from(File::open(archive.path())?)) 1150 1150 - .arg("--extract") 1151 1151 - .arg("out.txt"); 1152 1152 - extract.assert().success(); 1153 1153 - 1154 1154 - // Assert the files are identical 1155 1155 - working_dir 1156 1156 - .child("out.txt") 1157 1157 - .assert(predicate::path::eq_file(file.path())); 1158 1158 - 1159 1159 - Ok(()) 1160 1160 - } 1161 1161 - 1162 1162 - /// Zstd roundtrip using stdout 1163 1163 - /// Compressing: input = test.txt, output = stdout 1164 1164 - /// Extracting: input = test.txt.zst, output = stdout 1165 1165 - /// 1166 1166 - /// ``` bash 1167 1167 - /// cmprss zstd test.txt > test.txt.zst 1168 1168 - /// cmprss zstd --extract test.txt.zst > out.txt 1169 1169 - /// ``` 1170 1170 - #[test] 1171 1171 - fn zstd_roundtrip_stdout() -> Result<(), Box<dyn std::error::Error>> { 1172 1172 - let file = assert_fs::NamedTempFile::new("test.txt")?; 1173 1173 - file.write_str("garbage data for testing")?; 1174 1174 - 1175 1175 - let working_dir = assert_fs::TempDir::new()?; 1176 1176 - let archive = working_dir.child("test.txt.zst"); 1177 1177 - archive.assert(predicate::path::missing()); 1178 1178 - 1179 1179 - // Redirect stdout to file 1180 1180 - let mut compress = Command::cargo_bin("cmprss")?; 1181 1181 - compress 1182 1182 - .current_dir(&working_dir) 1183 1183 - .arg("zstd") 1184 1184 - .arg(file.path()) 1185 1185 - .stdout(Stdio::from(File::create(archive.path())?)); 1186 1186 - compress.assert().success(); 1187 1187 - archive.assert(predicate::path::is_file()); 1188 1188 - 1189 1189 - let output = working_dir.child("out.txt"); 1190 1190 - output.assert(predicate::path::missing()); 1191 1191 - 1192 1192 - let mut extract = Command::cargo_bin("cmprss")?; 1193 1193 - extract 1194 1194 - .current_dir(&working_dir) 1195 1195 - .arg("zstd") 1196 1196 - .arg("--extract") 1197 1197 - .arg(archive.path()) 1198 1198 - .stdout(Stdio::from(File::create(output.path())?)); 1199 1199 - extract.assert().success(); 1200 1200 - output.assert(predicate::path::is_file()); 1201 1201 - 1202 1202 - // Assert the files are identical 1203 1203 - output.assert(predicate::path::eq_file(file.path())); 1204 1204 - 1205 1205 - Ok(()) 1206 1206 - } 1207 1207 - 1208 1208 - /// Zstd roundtrip with compression level 1209 1209 - /// Compressing: input = test.txt, output = test.txt.zst, level = 9 1210 1210 - /// Extracting: input = test.txt.zst, output = test.txt 1211 1211 - /// 1212 1212 - /// ``` bash 1213 1213 - /// cmprss zstd --level 9 test.txt test.txt.zst 1214 1214 - /// cmprss zstd --extract test.txt.zst test.txt 1215 1215 - /// ``` 1216 1216 - #[test] 1217 1217 - fn zstd_roundtrip_with_level() -> Result<(), Box<dyn std::error::Error>> { 1218 1218 - let file = assert_fs::NamedTempFile::new("test.txt")?; 1219 1219 - file.write_str("garbage data for testing")?; 1220 1220 - 1221 1221 - let working_dir = assert_fs::TempDir::new()?; 1222 1222 - let archive = working_dir.child("test.txt.zst"); 1223 1223 - archive.assert(predicate::path::missing()); 1224 1224 - 1225 1225 - let mut compress = Command::cargo_bin("cmprss")?; 1226 1226 - compress 1227 1227 - .current_dir(&working_dir) 1228 1228 - .arg("zstd") 1229 1229 - .arg("--level") 1230 1230 - .arg("9") 1231 1231 - .arg(file.path()) 1232 1232 - .arg(archive.path()); 1233 1233 - compress.assert().success(); 1234 1234 - archive.assert(predicate::path::is_file()); 1235 1235 - 1236 1236 - let output = working_dir.child("test.txt"); 1237 1237 - 1238 1238 - let mut extract = Command::cargo_bin("cmprss")?; 1239 1239 - extract 1240 1240 - .current_dir(&working_dir) 1241 1241 - .arg("zstd") 1242 1242 - .arg("--extract") 1243 1243 - .arg(archive.path()) 1244 1244 - .arg(output.path()); 1245 1245 - extract.assert().success(); 1246 1246 - 1247 1247 - // Assert the files are identical 1248 1248 - output.assert(predicate::path::eq_file(file.path())); 1249 1249 - 1250 1250 - Ok(()) 1251 1251 - } 1252 1252 - 1253 1253 - #[test] 1254 1254 - fn lz4_roundtrip_explicit() -> Result<(), Box<dyn std::error::Error>> { 1255 1255 - let mut cmd = Command::cargo_bin("cmprss")?; 1256 1256 - let dir = assert_fs::TempDir::new()?; 1257 1257 - 1258 1258 - // Create a test file 1259 1259 - let test_file = dir.child("test.txt"); 1260 1260 - test_file.write_str("This is a test file for LZ4 compression.")?; 1261 1261 - 1262 1262 - // Create output paths 1263 1263 - let compressed_file = dir.child("test.txt.lz4"); 1264 1264 - let extracted_file = dir.child("test_extracted.txt"); 1265 1265 - 1266 1266 - // Compress the file 1267 1267 - cmd.arg("lz4") 1268 1268 - .arg("--compress") 1269 1269 - .arg(test_file.path()) 1270 1270 - .arg(compressed_file.path()) 1271 1271 - .arg("--progress=off"); 1272 1272 - 1273 1273 - cmd.assert().success(); 1274 1274 - compressed_file.assert(predicates::path::exists()); 1275 1275 - 1276 1276 - // Extract the file 1277 1277 - let mut cmd = Command::cargo_bin("cmprss")?; 1278 1278 - cmd.arg("lz4") 1279 1279 - .arg("--extract") 1280 1280 - .arg(compressed_file.path()) 1281 1281 - .arg(extracted_file.path()) 1282 1282 - .arg("--progress=off"); 1283 1283 - 1284 1284 - cmd.assert().success(); 1285 1285 - extracted_file.assert(predicates::path::exists()); 1286 1286 - 1287 1287 - // Verify the contents 1288 1288 - let original_content = std::fs::read_to_string(test_file.path())?; 1289 1289 - let extracted_content = std::fs::read_to_string(extracted_file.path())?; 1290 1290 - assert_eq!(original_content, extracted_content); 1291 1291 - 1292 1292 - Ok(()) 1293 1293 - } 1294 1294 - 1295 1295 - #[test] 1296 1296 - fn lz4_roundtrip_stdin() -> Result<(), Box<dyn std::error::Error>> { 1297 1297 - let mut cmd = Command::cargo_bin("cmprss")?; 1298 1298 - let dir = assert_fs::TempDir::new()?; 1299 1299 - 1300 1300 - // Create a test file 1301 1301 - let test_file = dir.child("test.txt"); 1302 1302 - test_file.write_str("This is a test file for LZ4 compression via stdin.")?; 1303 1303 - 1304 1304 - // Create output paths 1305 1305 - let compressed_file = dir.child("test.txt.lz4"); 1306 1306 - let extracted_file = dir.child("test_extracted.txt"); 1307 1307 - 1308 1308 - // Compress the file via stdin 1309 1309 - let test_content = std::fs::read_to_string(test_file.path())?; 1310 1310 - cmd.arg("lz4") 1311 1311 - .arg("--compress") 1312 1312 - .arg("--output") 1313 1313 - .arg(compressed_file.path()) 1314 1314 - .arg("--progress=off") 1315 1315 - .stdin(Stdio::piped()); 1316 1316 - 1317 1317 - let mut child = cmd.spawn()?; 1318 1318 - if let Some(stdin) = child.stdin.as_mut() { 1319 1319 - use std::io::Write; 1320 1320 - stdin.write_all(test_content.as_bytes())?; 1321 1321 - } 1322 1322 - let output = child.wait_with_output()?; 1323 1323 - assert!(output.status.success()); 1324 1324 - compressed_file.assert(predicate::path::exists()); 1325 1325 - 1326 1326 - // Extract the file 1327 1327 - let mut cmd = Command::cargo_bin("cmprss")?; 1328 1328 - cmd.arg("lz4") 1329 1329 - .arg("--extract") 1330 1330 - .arg(compressed_file.path()) 1331 1331 - .arg(extracted_file.path()) 1332 1332 - .arg("--progress=off"); 1333 1333 - 1334 1334 - cmd.assert().success(); 1335 1335 - extracted_file.assert(predicate::path::exists()); 1336 1336 - 1337 1337 - // Verify the contents 1338 1338 - let original_content = std::fs::read_to_string(test_file.path())?; 1339 1339 - let extracted_content = std::fs::read_to_string(extracted_file.path())?; 1340 1340 - assert_eq!(original_content, extracted_content); 1341 1341 - 1342 1342 - Ok(()) 1343 1343 - } 1344 1344 - 1345 1345 - #[test] 1346 1346 - fn lz4_roundtrip_stdout() -> Result<(), Box<dyn std::error::Error>> { 1347 1347 - let mut cmd = Command::cargo_bin("cmprss")?; 1348 1348 - let dir = assert_fs::TempDir::new()?; 1349 1349 - 1350 1350 - // Create a test file 1351 1351 - let test_file = dir.child("test.txt"); 1352 1352 - test_file.write_str("This is a test file for LZ4 compression to stdout.")?; 1353 1353 - 1354 1354 - // Create output paths 1355 1355 - let compressed_file = dir.child("test.txt.lz4"); 1356 1356 - let extracted_file = dir.child("test_extracted.txt"); 1357 1357 - 1358 1358 - // Compress the file 1359 1359 - cmd.arg("lz4") 1360 1360 - .arg("--compress") 1361 1361 - .arg(test_file.path()) 1362 1362 - .arg("--progress=off"); 1363 1363 - 1364 1364 - let output = cmd.output()?; 1365 1365 - assert!(output.status.success()); 1366 1366 - std::fs::write(compressed_file.path(), output.stdout)?; 1367 1367 - 1368 1368 - // Extract the file to stdout 1369 1369 - let mut cmd = Command::cargo_bin("cmprss")?; 1370 1370 - cmd.arg("lz4") 1371 1371 - .arg("--extract") 1372 1372 - .arg(compressed_file.path()) 1373 1373 - .arg("--progress=off"); 1374 1374 - 1375 1375 - let output = cmd.output()?; 1376 1376 - assert!(output.status.success()); 1377 1377 - std::fs::write(extracted_file.path(), output.stdout)?; 1378 1378 - 1379 1379 - // Verify the contents 1380 1380 - let original_content = std::fs::read_to_string(test_file.path())?; 1381 1381 - let extracted_content = std::fs::read_to_string(extracted_file.path())?; 1382 1382 - assert_eq!(original_content, extracted_content); 1383 1383 - 1384 1384 - Ok(()) 1385 1385 - } 1386 1386 - }

+24

tests/common/mod.rs

reviewed

··· 1 1 + use assert_fs::prelude::*; 2 2 + use predicates::prelude::*; 3 3 + 4 4 + pub fn create_test_file( 5 5 + name: &str, 6 6 + content: &str, 7 7 + ) -> Result<assert_fs::NamedTempFile, Box<dyn std::error::Error>> { 8 8 + let file = assert_fs::NamedTempFile::new(name)?; 9 9 + file.write_str(content)?; 10 10 + Ok(file) 11 11 + } 12 12 + 13 13 + pub fn create_working_dir() -> Result<assert_fs::TempDir, Box<dyn std::error::Error>> { 14 14 + Ok(assert_fs::TempDir::new()?) 15 15 + } 16 16 + 17 17 + #[allow(dead_code)] 18 18 + pub fn create_persistent_working_dir() -> Result<assert_fs::TempDir, Box<dyn std::error::Error>> { 19 19 + Ok(assert_fs::TempDir::new()?.into_persistent()) 20 20 + } 21 21 + 22 22 + pub fn assert_files_equal(file1: &std::path::Path, file2: &std::path::Path) { 23 23 + assert!(predicate::path::eq_file(file1).eval(file2)); 24 24 + }

+98

tests/gzip.rs

reviewed

··· 1 1 + use assert_cmd::prelude::*; 2 2 + use assert_fs::prelude::*; 3 3 + use predicates::prelude::*; 4 4 + use std::{ 5 5 + fs::File, 6 6 + process::{Command, Stdio}, 7 7 + }; 8 8 + 9 9 + mod common; 10 10 + use common::*; 11 11 + 12 12 + mod gzip { 13 13 + use super::*; 14 14 + 15 15 + mod roundtrip { 16 16 + use super::*; 17 17 + 18 18 + /// Gzip roundtrip using stdin 19 19 + /// Compressing: input = stdin, output = test.txt.gz 20 20 + /// Extracting: input = test.txt.gz, output = test.txt 21 21 + /// 22 22 + /// ``` bash 23 23 + /// cat test.txt | cmprss gzip test.txt.gz 24 24 + /// cmprss gzip --ignore-pipes --extract test.txt.gz 25 25 + /// ``` 26 26 + #[test] 27 27 + fn stdin() -> Result<(), Box<dyn std::error::Error>> { 28 28 + let file = create_test_file("test.txt", "garbage data for testing")?; 29 29 + let working_dir = create_working_dir()?; 30 30 + let archive = working_dir.child("test.txt.gz"); 31 31 + archive.assert(predicate::path::missing()); 32 32 + 33 33 + // Pipe file to stdin 34 34 + let mut compress = Command::cargo_bin("cmprss")?; 35 35 + compress 36 36 + .current_dir(&working_dir) 37 37 + .arg("gzip") 38 38 + .arg("test.txt.gz") 39 39 + .stdin(Stdio::from(File::open(file.path())?)); 40 40 + compress.assert().success(); 41 41 + archive.assert(predicate::path::is_file()); 42 42 + 43 43 + let mut extract = Command::cargo_bin("cmprss")?; 44 44 + extract 45 45 + .current_dir(&working_dir) 46 46 + .arg("gzip") 47 47 + .arg("--ignore-pipes") 48 48 + .arg("--extract") 49 49 + .arg(archive.path()); 50 50 + extract.assert().success(); 51 51 + 52 52 + // Assert the files are identical 53 53 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 54 54 + 55 55 + Ok(()) 56 56 + } 57 57 + 58 58 + /// Gzip roundtrip using filename inference 59 59 + /// Compressing: input = stdin, output = default filename (archive.gz) 60 60 + /// Extracting: input = archive.gz, output = default filename (archive) 61 61 + /// 62 62 + /// ``` bash 63 63 + /// cat test.txt | cmprss gzip 64 64 + /// cmprss gzip --ignore-pipes --extract archive.gz 65 65 + /// ``` 66 66 + #[test] 67 67 + fn inferred_output_filenames() -> Result<(), Box<dyn std::error::Error>> { 68 68 + let file = create_test_file("test.txt", "garbage data for testing")?; 69 69 + let working_dir = create_working_dir()?; 70 70 + let archive = working_dir.child("archive.gz"); // default filename 71 71 + archive.assert(predicate::path::missing()); 72 72 + 73 73 + // Pipe file to stdin 74 74 + let mut compress = Command::cargo_bin("cmprss")?; 75 75 + compress 76 76 + .current_dir(&working_dir) 77 77 + .arg("gzip") 78 78 + .arg("--ignore-stdout") 79 79 + .stdin(Stdio::from(File::open(file.path())?)); 80 80 + compress.assert().success(); 81 81 + archive.assert(predicate::path::is_file()); 82 82 + 83 83 + let mut extract = Command::cargo_bin("cmprss")?; 84 84 + extract 85 85 + .current_dir(&working_dir) 86 86 + .arg("gzip") 87 87 + .arg("--ignore-pipes") 88 88 + .arg("--extract") 89 89 + .arg(archive.path()); 90 90 + extract.assert().success(); 91 91 + 92 92 + // Assert the files are identical 93 93 + assert_files_equal(file.path(), &working_dir.child("archive")); 94 94 + 95 95 + Ok(()) 96 96 + } 97 97 + } 98 98 + }

+154

tests/lz4.rs

reviewed

··· 1 1 + use assert_cmd::prelude::*; 2 2 + use assert_fs::prelude::*; 3 3 + use predicates::prelude::*; 4 4 + use std::{ 5 5 + fs::File, 6 6 + process::{Command, Stdio}, 7 7 + }; 8 8 + 9 9 + mod common; 10 10 + use common::*; 11 11 + 12 12 + mod lz4 { 13 13 + use super::*; 14 14 + 15 15 + mod roundtrip { 16 16 + use super::*; 17 17 + 18 18 + /// LZ4 roundtrip using explicit filenames 19 19 + /// Compressing: input = test.txt, output = test.txt.lz4 20 20 + /// Extracting: input = test.txt.lz4, output = test.txt 21 21 + /// 22 22 + /// ``` bash 23 23 + /// cmprss lz4 test.txt test.txt.lz4 24 24 + /// cmprss lz4 --extract test.txt.lz4 test.txt 25 25 + /// ``` 26 26 + #[test] 27 27 + fn explicit() -> Result<(), Box<dyn std::error::Error>> { 28 28 + let file = create_test_file("test.txt", "This is a test file for LZ4 compression.")?; 29 29 + let working_dir = create_working_dir()?; 30 30 + let archive = working_dir.child("test.txt.lz4"); 31 31 + let extracted_file = working_dir.child("test_extracted.txt"); 32 32 + 33 33 + // Compress the file 34 34 + let mut compress = Command::cargo_bin("cmprss")?; 35 35 + compress 36 36 + .arg("lz4") 37 37 + .arg("--compress") 38 38 + .arg(file.path()) 39 39 + .arg(archive.path()) 40 40 + .arg("--progress=off"); 41 41 + compress.assert().success(); 42 42 + archive.assert(predicate::path::exists()); 43 43 + 44 44 + // Extract the file 45 45 + let mut extract = Command::cargo_bin("cmprss")?; 46 46 + extract 47 47 + .arg("lz4") 48 48 + .arg("--extract") 49 49 + .arg(archive.path()) 50 50 + .arg(extracted_file.path()) 51 51 + .arg("--progress=off"); 52 52 + extract.assert().success(); 53 53 + extracted_file.assert(predicate::path::exists()); 54 54 + 55 55 + // Verify the contents 56 56 + assert_files_equal(file.path(), extracted_file.path()); 57 57 + 58 58 + Ok(()) 59 59 + } 60 60 + 61 61 + /// LZ4 roundtrip using stdin 62 62 + /// Compressing: input = stdin, output = test.txt.lz4 63 63 + /// Extracting: input = test.txt.lz4, output = test.txt 64 64 + /// 65 65 + /// ``` bash 66 66 + /// cat test.txt | cmprss lz4 test.txt.lz4 67 67 + /// cmprss lz4 --extract test.txt.lz4 test.txt 68 68 + /// ``` 69 69 + #[test] 70 70 + fn stdin() -> Result<(), Box<dyn std::error::Error>> { 71 71 + let file = create_test_file( 72 72 + "test.txt", 73 73 + "This is a test file for LZ4 compression via stdin.", 74 74 + )?; 75 75 + let working_dir = create_working_dir()?; 76 76 + let archive = working_dir.child("test.txt.lz4"); 77 77 + let extracted_file = working_dir.child("test_extracted.txt"); 78 78 + 79 79 + // Compress the file via stdin 80 80 + let mut compress = Command::cargo_bin("cmprss")?; 81 81 + compress 82 82 + .arg("lz4") 83 83 + .arg("--compress") 84 84 + .arg("--output") 85 85 + .arg(archive.path()) 86 86 + .arg("--progress=off") 87 87 + .stdin(Stdio::from(File::open(file.path())?)); 88 88 + compress.assert().success(); 89 89 + archive.assert(predicate::path::exists()); 90 90 + 91 91 + // Extract the file 92 92 + let mut extract = Command::cargo_bin("cmprss")?; 93 93 + extract 94 94 + .arg("lz4") 95 95 + .arg("--extract") 96 96 + .arg(archive.path()) 97 97 + .arg(extracted_file.path()) 98 98 + .arg("--progress=off"); 99 99 + extract.assert().success(); 100 100 + extracted_file.assert(predicate::path::exists()); 101 101 + 102 102 + // Verify the contents 103 103 + assert_files_equal(file.path(), extracted_file.path()); 104 104 + 105 105 + Ok(()) 106 106 + } 107 107 + 108 108 + /// LZ4 roundtrip using stdout 109 109 + /// Compressing: input = test.txt, output = stdout 110 110 + /// Extracting: input = test.txt.lz4, output = stdout 111 111 + /// 112 112 + /// ``` bash 113 113 + /// cmprss lz4 test.txt > test.txt.lz4 114 114 + /// cmprss lz4 --extract test.txt.lz4 > test.txt 115 115 + /// ``` 116 116 + #[test] 117 117 + fn stdout() -> Result<(), Box<dyn std::error::Error>> { 118 118 + let file = create_test_file( 119 119 + "test.txt", 120 120 + "This is a test file for LZ4 compression to stdout.", 121 121 + )?; 122 122 + let working_dir = create_working_dir()?; 123 123 + let archive = working_dir.child("test.txt.lz4"); 124 124 + let extracted_file = working_dir.child("test_extracted.txt"); 125 125 + 126 126 + // Compress the file 127 127 + let mut compress = Command::cargo_bin("cmprss")?; 128 128 + compress 129 129 + .arg("lz4") 130 130 + .arg("--compress") 131 131 + .arg(file.path()) 132 132 + .arg("--progress=off") 133 133 + .stdout(Stdio::from(File::create(archive.path())?)); 134 134 + compress.assert().success(); 135 135 + archive.assert(predicate::path::exists()); 136 136 + 137 137 + // Extract the file to stdout 138 138 + let mut extract = Command::cargo_bin("cmprss")?; 139 139 + extract 140 140 + .arg("lz4") 141 141 + .arg("--extract") 142 142 + .arg(archive.path()) 143 143 + .arg("--progress=off") 144 144 + .stdout(Stdio::from(File::create(extracted_file.path())?)); 145 145 + extract.assert().success(); 146 146 + extracted_file.assert(predicate::path::exists()); 147 147 + 148 148 + // Verify the contents 149 149 + assert_files_equal(file.path(), extracted_file.path()); 150 150 + 151 151 + Ok(()) 152 152 + } 153 153 + } 154 154 + }

+397

tests/magic.rs

reviewed

··· 1 1 + use assert_cmd::prelude::*; 2 2 + use assert_fs::prelude::*; 3 3 + use predicates::prelude::*; 4 4 + use std::{ 5 5 + fs::File, 6 6 + process::{Command, Stdio}, 7 7 + }; 8 8 + 9 9 + mod common; 10 10 + use common::*; 11 11 + 12 12 + mod magic { 13 13 + use super::*; 14 14 + 15 15 + mod roundtrip { 16 16 + use super::*; 17 17 + 18 18 + /// Magic roundtrip using stdin 19 19 + /// Compressing: input = stdin, output = test.txt.gz 20 20 + /// Extracting: input = test.txt.gz, output = test.txt 21 21 + /// 22 22 + /// ``` bash 23 23 + /// cat test.txt | cmprss test.txt.gz 24 24 + /// cmprss gz --extract test.txt.gz out.txt 25 25 + /// ``` 26 26 + #[test] 27 27 + fn stdin() -> Result<(), Box<dyn std::error::Error>> { 28 28 + let file = create_test_file("test.txt", "garbage data for testing")?; 29 29 + let working_dir = create_working_dir()?; 30 30 + let archive = working_dir.child("test.txt.gz"); 31 31 + archive.assert(predicate::path::missing()); 32 32 + 33 33 + // Pipe file to stdin 34 34 + let mut compress = Command::cargo_bin("cmprss")?; 35 35 + compress 36 36 + .current_dir(&working_dir) 37 37 + .arg("--ignore-stdout") 38 38 + .arg("test.txt.gz") 39 39 + .stdin(Stdio::from(File::open(file.path())?)); 40 40 + compress.assert().success(); 41 41 + archive.assert(predicate::path::is_file()); 42 42 + 43 43 + let mut extract = Command::cargo_bin("cmprss")?; 44 44 + extract 45 45 + .current_dir(&working_dir) 46 46 + .arg("gz") 47 47 + .arg("--ignore-pipes") 48 48 + .arg("--extract") 49 49 + .arg("test.txt.gz"); 50 50 + extract.assert().success(); 51 51 + 52 52 + // Assert the files are identical 53 53 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 54 54 + 55 55 + Ok(()) 56 56 + } 57 57 + 58 58 + /// Magic roundtrip using files 59 59 + /// Compressing: input = test.txt, output = test.txt.gz 60 60 + /// Extracting: input = test.txt.gz, output = stdout 61 61 + /// 62 62 + /// ``` bash 63 63 + /// cmprss test.txt test.txt.gz 64 64 + /// cmprss test.txt.gz out.txt 65 65 + /// ``` 66 66 + #[test] 67 67 + fn files() -> Result<(), Box<dyn std::error::Error>> { 68 68 + let file = create_test_file("test.txt", "garbage data for testing")?; 69 69 + let working_dir = create_working_dir()?; 70 70 + let archive = working_dir.child("test.txt.gz"); 71 71 + archive.assert(predicate::path::missing()); 72 72 + 73 73 + // Compress file to an archive 74 74 + let mut compress = Command::cargo_bin("cmprss")?; 75 75 + compress 76 76 + .current_dir(&working_dir) 77 77 + .arg("--ignore-pipes") 78 78 + .arg(file.path()) 79 79 + .arg("test.txt.gz"); 80 80 + compress.assert().success(); 81 81 + archive.assert(predicate::path::is_file()); 82 82 + 83 83 + // Extract file to given file 84 84 + let mut extract = Command::cargo_bin("cmprss")?; 85 85 + extract 86 86 + .current_dir(&working_dir) 87 87 + .arg("--ignore-pipes") 88 88 + .arg("test.txt.gz") 89 89 + .arg("out.txt"); 90 90 + extract.assert().success(); 91 91 + 92 92 + // Assert the files are identical 93 93 + assert_files_equal(file.path(), &working_dir.child("out.txt")); 94 94 + 95 95 + Ok(()) 96 96 + } 97 97 + 98 98 + /// Magic roundtrip using stdout decompression 99 99 + /// Compressing: input = test.txt, output = test.txt.gz 100 100 + /// Extracting: input = test.txt.gz, output = stdout 101 101 + /// 102 102 + /// ``` bash 103 103 + /// cmprss test.txt test.txt.gz 104 104 + /// cmprss test.txt.gz > out.txt 105 105 + /// ``` 106 106 + #[test] 107 107 + fn stdout_decompression() -> Result<(), Box<dyn std::error::Error>> { 108 108 + let file = create_test_file("test.txt", "garbage data for testing")?; 109 109 + let working_dir = create_working_dir()?; 110 110 + let archive = working_dir.child("test.txt.gz"); 111 111 + archive.assert(predicate::path::missing()); 112 112 + 113 113 + let out_file = working_dir.child("out.txt"); 114 114 + 115 115 + // Compress file to an archive 116 116 + let mut compress = Command::cargo_bin("cmprss")?; 117 117 + compress 118 118 + .current_dir(&working_dir) 119 119 + .arg("--ignore-pipes") 120 120 + .arg(file.path()) 121 121 + .arg("test.txt.gz"); 122 122 + compress.assert().success(); 123 123 + archive.assert(predicate::path::is_file()); 124 124 + 125 125 + // Extract file to stdout 126 126 + let mut extract = Command::cargo_bin("cmprss")?; 127 127 + extract 128 128 + .current_dir(&working_dir) 129 129 + .arg("--ignore-stdin") 130 130 + .arg("test.txt.gz") 131 131 + .stdout(Stdio::from(File::create(&out_file)?)); 132 132 + extract.assert().success(); 133 133 + 134 134 + // Assert the files are identical 135 135 + assert_files_equal(file.path(), out_file.path()); 136 136 + 137 137 + Ok(()) 138 138 + } 139 139 + 140 140 + /// Magic roundtrip using stdin compression 141 141 + /// Compressing: input = stdin, output = test.txt.gz 142 142 + /// Extracting: input = test.txt.gz, output = test.txt 143 143 + /// 144 144 + /// ``` bash 145 145 + /// cat test.txt | cmprss test.txt.gz 146 146 + /// cmprss test.txt.gz out.txt 147 147 + /// ``` 148 148 + #[test] 149 149 + fn stdin_compression() -> Result<(), Box<dyn std::error::Error>> { 150 150 + let file = create_test_file("test.txt", "garbage data for testing")?; 151 151 + let working_dir = create_working_dir()?; 152 152 + let archive = working_dir.child("test.txt.gz"); 153 153 + archive.assert(predicate::path::missing()); 154 154 + 155 155 + let out_file = working_dir.child("out.txt"); 156 156 + 157 157 + // Compress stdin to an archive 158 158 + let mut compress = Command::cargo_bin("cmprss")?; 159 159 + compress 160 160 + .current_dir(&working_dir) 161 161 + .arg("--ignore-stdout") 162 162 + .arg("test.txt.gz") 163 163 + .stdin(Stdio::from(File::open(file.path())?)); 164 164 + compress.assert().success(); 165 165 + archive.assert(predicate::path::is_file()); 166 166 + 167 167 + // Extract file to given file 168 168 + let mut extract = Command::cargo_bin("cmprss")?; 169 169 + extract 170 170 + .current_dir(&working_dir) 171 171 + .arg("--ignore-pipes") 172 172 + .arg("test.txt.gz") 173 173 + .arg(out_file.path()); 174 174 + extract.assert().success(); 175 175 + 176 176 + // Assert the files are identical 177 177 + assert_files_equal(file.path(), out_file.path()); 178 178 + 179 179 + Ok(()) 180 180 + } 181 181 + 182 182 + /// Magic roundtrip using default filenames 183 183 + /// Compressing: input = test.txt, output = test.txt.gz 184 184 + /// Extracting: input = test.txt.gz, output = <default> 185 185 + /// 186 186 + /// ``` bash 187 187 + /// cmprss test.txt test.txt.gz 188 188 + /// cmprss test.txt.gz 189 189 + /// ``` 190 190 + #[test] 191 191 + fn default_filenames() -> Result<(), Box<dyn std::error::Error>> { 192 192 + let file = create_test_file("test.txt", "garbage data for testing")?; 193 193 + let working_dir = create_working_dir()?; 194 194 + let archive = working_dir.child("test.txt.gz"); 195 195 + archive.assert(predicate::path::missing()); 196 196 + 197 197 + // Compress file to an archive 198 198 + let mut compress = Command::cargo_bin("cmprss")?; 199 199 + compress 200 200 + .current_dir(&working_dir) 201 201 + .arg("--ignore-pipes") 202 202 + .arg(file.path()) 203 203 + .arg("test.txt.gz"); 204 204 + compress.assert().success(); 205 205 + archive.assert(predicate::path::is_file()); 206 206 + 207 207 + // Extract file to default filename 208 208 + let mut extract = Command::cargo_bin("cmprss")?; 209 209 + extract 210 210 + .current_dir(&working_dir) 211 211 + .arg("--ignore-pipes") 212 212 + .arg("test.txt.gz"); 213 213 + extract.assert().success(); 214 214 + 215 215 + // Assert the files are identical 216 216 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 217 217 + 218 218 + Ok(()) 219 219 + } 220 220 + 221 221 + /// Magic roundtrip using multiple files with tar 222 222 + /// Compressing: input = test.txt/test2.txt, output = archive.tar 223 223 + /// Extracting: input = archive.tar, output = <default> 224 224 + /// 225 225 + /// ``` bash 226 226 + /// cmprss test.txt test2.txt archive.tar 227 227 + /// cmprss archive.tar 228 228 + /// ``` 229 229 + #[test] 230 230 + fn multiple_files_tar() -> Result<(), Box<dyn std::error::Error>> { 231 231 + let file = create_test_file("test.txt", "garbage data for testing")?; 232 232 + let file2 = create_test_file("test2.txt", "more garbage data for testing")?; 233 233 + let working_dir = create_working_dir()?; 234 234 + let archive = working_dir.child("archive.tar"); 235 235 + archive.assert(predicate::path::missing()); 236 236 + 237 237 + // Compress files to an archive 238 238 + let mut compress = Command::cargo_bin("cmprss")?; 239 239 + compress 240 240 + .current_dir(&working_dir) 241 241 + .arg("--ignore-pipes") 242 242 + .arg(file.path()) 243 243 + .arg(file2.path()) 244 244 + .arg("archive.tar"); 245 245 + compress.assert().success(); 246 246 + archive.assert(predicate::path::is_file()); 247 247 + 248 248 + // Extract file to default filename 249 249 + let mut extract = Command::cargo_bin("cmprss")?; 250 250 + extract 251 251 + .current_dir(&working_dir) 252 252 + .arg("--ignore-pipes") 253 253 + .arg("archive.tar"); 254 254 + extract.assert().success(); 255 255 + 256 256 + // Assert the files are identical 257 257 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 258 258 + assert_files_equal(file2.path(), &working_dir.child("test2.txt")); 259 259 + 260 260 + Ok(()) 261 261 + } 262 262 + 263 263 + /// Magic roundtrip with tar.gz 264 264 + /// Infer things as much as possible 265 265 + /// Compressing: input = test.txt + test2.txt, output = test.tar.gz 266 266 + /// Extracting: input = test.tar.gz, output = test.txt + test2.txt 267 267 + /// 268 268 + /// ``` bash 269 269 + /// cmprss test.txt test2.txt archive.tar 270 270 + /// cmprss archive.tar archive.tar.gz 271 271 + /// cmprss archive.tar.gz archive.tar 272 272 + /// cmprss archive.tar 273 273 + /// ``` 274 274 + #[test] 275 275 + fn tar_gz() -> Result<(), Box<dyn std::error::Error>> { 276 276 + let file = create_test_file("test.txt", "garbage data for testing")?; 277 277 + let file2 = create_test_file("test2.txt", "more garbage data for testing")?; 278 278 + let working_dir = create_working_dir()?; 279 279 + let archive = working_dir.child("archive.tar"); 280 280 + archive.assert(predicate::path::missing()); 281 281 + let archive2 = working_dir.child("archive.tar.gz"); 282 282 + archive2.assert(predicate::path::missing()); 283 283 + 284 284 + let extract_dir = create_working_dir()?; 285 285 + 286 286 + // Compress files to an archive 287 287 + let mut compress = Command::cargo_bin("cmprss")?; 288 288 + compress 289 289 + .current_dir(&working_dir) 290 290 + .arg("--ignore-pipes") 291 291 + .arg(file.path()) 292 292 + .arg(file2.path()) 293 293 + .arg("archive.tar"); 294 294 + compress.assert().success(); 295 295 + archive.assert(predicate::path::is_file()); 296 296 + 297 297 + // Compress tar to an archive 298 298 + let mut compress2 = Command::cargo_bin("cmprss")?; 299 299 + compress2 300 300 + .current_dir(&working_dir) 301 301 + .arg("--ignore-pipes") 302 302 + .arg("archive.tar") 303 303 + .arg("archive.tar.gz"); 304 304 + compress2.assert().success(); 305 305 + archive2.assert(predicate::path::is_file()); 306 306 + 307 307 + // Extract file to default filename 308 308 + let mut extract = Command::cargo_bin("cmprss")?; 309 309 + extract 310 310 + .current_dir(&extract_dir) 311 311 + .arg("--ignore-pipes") 312 312 + .arg(archive2.path()) 313 313 + .arg("archive.tar"); 314 314 + extract.assert().success(); 315 315 + 316 316 + // Extract file to default filename 317 317 + let mut extract2 = Command::cargo_bin("cmprss")?; 318 318 + extract2 319 319 + .current_dir(&extract_dir) 320 320 + .arg("--ignore-pipes") 321 321 + .arg("archive.tar"); 322 322 + extract2.assert().success(); 323 323 + 324 324 + // Assert the files are identical 325 325 + assert_files_equal(file.path(), &extract_dir.child("test.txt")); 326 326 + assert_files_equal(file2.path(), &extract_dir.child("test2.txt")); 327 327 + 328 328 + Ok(()) 329 329 + } 330 330 + 331 331 + /// Magic roundtrip with tar.gz using pipes 332 332 + /// Infer things as much as possible 333 333 + /// Compressing: input = test.txt + test2.txt, output = test.tar.gz 334 334 + /// Extracting: input = test.tar.gz, output = test.txt + test2.txt 335 335 + /// 336 336 + /// ``` bash 337 337 + /// cmprss tar test.txt test2.txt | cmprss gzip | cmprss gzip --extract | cmprss tar --extract 338 338 + /// ``` 339 339 + #[test] 340 340 + fn tar_gz_pipes() -> Result<(), Box<dyn std::error::Error>> { 341 341 + let file = create_test_file("test.txt", "garbage data for testing")?; 342 342 + let file2 = create_test_file("test2.txt", "more garbage data for testing")?; 343 343 + let working_dir = create_working_dir()?; 344 344 + let tee1 = working_dir.child("tee1"); 345 345 + let tee2 = working_dir.child("tee2"); 346 346 + let tee3 = working_dir.child("tee3"); 347 347 + 348 348 + let extract_dir = create_working_dir()?; 349 349 + 350 350 + let mut compress = Command::cargo_bin("cmprss")?; 351 351 + compress 352 352 + .current_dir(&working_dir) 353 353 + .arg("tar") 354 354 + .arg("--ignore-stdin") 355 355 + .arg(file.path()) 356 356 + .arg(file2.path()) 357 357 + .stdout(Stdio::from(File::create(tee1.path())?)); 358 358 + compress.assert().success(); 359 359 + tee1.assert(predicate::path::is_file()); 360 360 + 361 361 + let mut compress2 = Command::cargo_bin("cmprss")?; 362 362 + compress2 363 363 + .current_dir(&working_dir) 364 364 + .arg("gzip") 365 365 + .stdin(Stdio::from(File::open(tee1.path())?)) 366 366 + .stdout(Stdio::from(File::create(tee2.path())?)); 367 367 + compress2.assert().success(); 368 368 + tee2.assert(predicate::path::is_file()); 369 369 + 370 370 + let mut extract = Command::cargo_bin("cmprss")?; 371 371 + extract 372 372 + .current_dir(&working_dir) 373 373 + .arg("gzip") 374 374 + .arg("--extract") 375 375 + .stdin(Stdio::from(File::open(tee2.path())?)) 376 376 + .stdout(Stdio::from(File::create(tee3.path())?)); 377 377 + extract.assert().success(); 378 378 + tee3.assert(predicate::path::is_file()); 379 379 + 380 380 + // Extract file to default filename 381 381 + let mut extract2 = Command::cargo_bin("cmprss")?; 382 382 + extract2 383 383 + .current_dir(&extract_dir) 384 384 + .arg("tar") 385 385 + .arg("--ignore-stdout") 386 386 + .arg("--extract") 387 387 + .stdin(Stdio::from(File::open(tee3.path())?)); 388 388 + extract2.assert().success(); 389 389 + 390 390 + // Assert the files are identical 391 391 + assert_files_equal(file.path(), &extract_dir.child("test.txt")); 392 392 + assert_files_equal(file2.path(), &extract_dir.child("test2.txt")); 393 393 + 394 394 + Ok(()) 395 395 + } 396 396 + } 397 397 + }

+165

tests/tar.rs

reviewed

··· 1 1 + use assert_cmd::prelude::*; 2 2 + use assert_fs::prelude::*; 3 3 + use predicates::prelude::*; 4 4 + use std::process::Command; 5 5 + 6 6 + mod common; 7 7 + use common::*; 8 8 + 9 9 + mod tar { 10 10 + use super::*; 11 11 + 12 12 + mod roundtrip { 13 13 + use super::*; 14 14 + 15 15 + /// Tar roundtrip with a single file 16 16 + /// 17 17 + /// ``` bash 18 18 + /// cmprss tar test.txt archive.tar 19 19 + /// cmprss tar --extract archive.tar . 20 20 + /// ``` 21 21 + #[test] 22 22 + fn explicit() -> Result<(), Box<dyn std::error::Error>> { 23 23 + let file = create_test_file("test.txt", "garbage data for testing")?; 24 24 + let working_dir = create_working_dir()?; 25 25 + let archive = working_dir.child("archive.tar"); 26 26 + archive.assert(predicate::path::missing()); 27 27 + 28 28 + let mut compress = Command::cargo_bin("cmprss")?; 29 29 + compress.arg("tar").arg(file.path()).arg(archive.path()); 30 30 + compress.assert().success(); 31 31 + archive.assert(predicate::path::is_file()); 32 32 + 33 33 + let mut extract = Command::cargo_bin("cmprss")?; 34 34 + extract 35 35 + .arg("tar") 36 36 + .arg("--extract") 37 37 + .arg(archive.path()) 38 38 + .arg(working_dir.path()); 39 39 + extract.assert().success(); 40 40 + 41 41 + // Assert the files are identical 42 42 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 43 43 + 44 44 + Ok(()) 45 45 + } 46 46 + 47 47 + /// Tar roundtrip with multiple files 48 48 + /// 49 49 + /// ``` bash 50 50 + /// cmprss tar test.txt test2.txt archive.tar 51 51 + /// cmprss tar --extract archive.tar . 52 52 + /// ``` 53 53 + #[test] 54 54 + fn explicit_two() -> Result<(), Box<dyn std::error::Error>> { 55 55 + let file = create_test_file("test.txt", "garbage data for testing")?; 56 56 + let file2 = create_test_file("test2.txt", "more garbage data for testing")?; 57 57 + let working_dir = create_working_dir()?; 58 58 + let archive = working_dir.child("archive.tar"); 59 59 + archive.assert(predicate::path::missing()); 60 60 + 61 61 + let mut compress = Command::cargo_bin("cmprss")?; 62 62 + compress 63 63 + .arg("tar") 64 64 + .arg(file.path()) 65 65 + .arg(file2.path()) 66 66 + .arg(archive.path()); 67 67 + compress.assert().success(); 68 68 + archive.assert(predicate::path::is_file()); 69 69 + 70 70 + let mut extract = Command::cargo_bin("cmprss")?; 71 71 + extract 72 72 + .arg("tar") 73 73 + .arg("--extract") 74 74 + .arg(archive.path()) 75 75 + .arg(working_dir.path()); 76 76 + extract.assert().success(); 77 77 + 78 78 + // Assert the files are identical 79 79 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 80 80 + assert_files_equal(file2.path(), &working_dir.child("test2.txt")); 81 81 + 82 82 + Ok(()) 83 83 + } 84 84 + 85 85 + /// Tar roundtrip with a single file inferring output filename 86 86 + /// Compressing: output = './test.txt.tar' 87 87 + /// Extracting: output = '.' 88 88 + /// 89 89 + /// ``` bash 90 90 + /// cmprss tar test.txt 91 91 + /// cmprss tar --extract test.txt.tar 92 92 + /// ``` 93 93 + #[test] 94 94 + fn implicit() -> Result<(), Box<dyn std::error::Error>> { 95 95 + let file = create_test_file("test.txt", "garbage data for testing")?; 96 96 + let working_dir = create_persistent_working_dir()?; 97 97 + let archive = working_dir.child("test.txt.tar"); 98 98 + archive.assert(predicate::path::missing()); 99 99 + 100 100 + let mut compress = Command::cargo_bin("cmprss")?; 101 101 + compress 102 102 + .current_dir(&working_dir) 103 103 + .arg("tar") 104 104 + .arg("--ignore-pipes") 105 105 + .arg(file.path()); 106 106 + compress.assert().success(); 107 107 + archive.assert(predicate::path::is_file()); 108 108 + 109 109 + let mut extract = Command::cargo_bin("cmprss")?; 110 110 + extract 111 111 + .current_dir(&working_dir) 112 112 + .arg("tar") 113 113 + .arg("--ignore-pipes") 114 114 + .arg("--extract") 115 115 + .arg(archive.path()); 116 116 + extract.assert().success(); 117 117 + 118 118 + // Assert the files are identical 119 119 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 120 120 + 121 121 + Ok(()) 122 122 + } 123 123 + 124 124 + /// Tar roundtrip with multiple files inferring output 125 125 + /// Uses the first file's name to generate the output filename 126 126 + /// Compressing: output = './test.txt.tar' 127 127 + /// Extracting: output = '.' 128 128 + /// 129 129 + /// ``` bash 130 130 + /// cmprss tar test.txt test2.txt 131 131 + /// cmprss tar test.txt.tar 132 132 + /// ``` 133 133 + #[test] 134 134 + fn implicit_two() -> Result<(), Box<dyn std::error::Error>> { 135 135 + let file = create_test_file("test.txt", "garbage data for testing")?; 136 136 + let file2 = create_test_file("test2.txt", "more garbage data for testing")?; 137 137 + let working_dir = create_persistent_working_dir()?; 138 138 + let archive = working_dir.child("test.txt.tar"); 139 139 + archive.assert(predicate::path::missing()); 140 140 + 141 141 + let mut compress = Command::cargo_bin("cmprss")?; 142 142 + compress 143 143 + .current_dir(&working_dir) 144 144 + .arg("tar") 145 145 + .arg("--ignore-pipes") 146 146 + .arg(file.path()) 147 147 + .arg(file2.path()); 148 148 + compress.assert().success(); 149 149 + archive.assert(predicate::path::is_file()); 150 150 + 151 151 + let mut extract = Command::cargo_bin("cmprss")?; 152 152 + extract 153 153 + .current_dir(&working_dir) 154 154 + .arg("--ignore-pipes") 155 155 + .arg(archive.path()); 156 156 + extract.assert().success(); 157 157 + 158 158 + // Assert the files are identical 159 159 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 160 160 + assert_files_equal(file2.path(), &working_dir.child("test2.txt")); 161 161 + 162 162 + Ok(()) 163 163 + } 164 164 + } 165 165 + }

+139

tests/xz.rs

reviewed

··· 1 1 + use assert_cmd::prelude::*; 2 2 + use assert_fs::prelude::*; 3 3 + use predicates::prelude::*; 4 4 + use std::{ 5 5 + fs::File, 6 6 + process::{Command, Stdio}, 7 7 + }; 8 8 + 9 9 + mod common; 10 10 + use common::*; 11 11 + 12 12 + mod xz { 13 13 + use super::*; 14 14 + 15 15 + mod roundtrip { 16 16 + use super::*; 17 17 + 18 18 + /// Xz roundtrip using files 19 19 + /// Compressing: input = test.txt, output = test.txt.xz 20 20 + /// Extracting: input = test.txt.xz, output = test.txt 21 21 + /// 22 22 + /// ``` bash 23 23 + /// cmprss xz test.txt test.txt.xz 24 24 + /// cmprss xz --extract --ignore-pipes test.txt.xz 25 25 + /// ``` 26 26 + #[test] 27 27 + fn explicit() -> Result<(), Box<dyn std::error::Error>> { 28 28 + let file = create_test_file("test.txt", "garbage data for testing")?; 29 29 + let working_dir = create_working_dir()?; 30 30 + let archive = working_dir.child("test.txt.xz"); 31 31 + archive.assert(predicate::path::missing()); 32 32 + 33 33 + let mut compress = Command::cargo_bin("cmprss")?; 34 34 + compress 35 35 + .current_dir(&working_dir) 36 36 + .arg("xz") 37 37 + .arg(file.path()) 38 38 + .arg(archive.path()); 39 39 + compress.assert().success(); 40 40 + archive.assert(predicate::path::is_file()); 41 41 + 42 42 + let mut extract = Command::cargo_bin("cmprss")?; 43 43 + extract 44 44 + .current_dir(&working_dir) 45 45 + .arg("xz") 46 46 + .arg("--ignore-pipes") 47 47 + .arg("--extract") 48 48 + .arg(archive.path()); 49 49 + extract.assert().success(); 50 50 + 51 51 + // Assert the files are identical 52 52 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 53 53 + 54 54 + Ok(()) 55 55 + } 56 56 + 57 57 + /// Xz roundtrip using stdin 58 58 + /// Compressing: input = stdin, output = test.txt.xz 59 59 + /// Extracting: input = stdin(test.txt.xz), output = test.txt 60 60 + /// 61 61 + /// ``` bash 62 62 + /// cat test.txt | cmprss xz test.txt.xz 63 63 + /// cat test.txt.xz | cmprss xz --extract out.txt 64 64 + /// ``` 65 65 + #[test] 66 66 + fn stdin() -> Result<(), Box<dyn std::error::Error>> { 67 67 + let file = create_test_file("test.txt", "garbage data for testing")?; 68 68 + let working_dir = create_working_dir()?; 69 69 + let archive = working_dir.child("test.txt.xz"); 70 70 + archive.assert(predicate::path::missing()); 71 71 + 72 72 + // Pipe file to stdin 73 73 + let mut compress = Command::cargo_bin("cmprss")?; 74 74 + compress 75 75 + .current_dir(&working_dir) 76 76 + .arg("xz") 77 77 + .arg("test.txt.xz") 78 78 + .stdin(Stdio::from(File::open(file.path())?)); 79 79 + compress.assert().success(); 80 80 + archive.assert(predicate::path::is_file()); 81 81 + 82 82 + let mut extract = Command::cargo_bin("cmprss")?; 83 83 + extract 84 84 + .current_dir(&working_dir) 85 85 + .arg("xz") 86 86 + .stdin(Stdio::from(File::open(archive.path())?)) 87 87 + .arg("--extract") 88 88 + .arg("out.txt"); 89 89 + extract.assert().success(); 90 90 + 91 91 + // Assert the files are identical 92 92 + assert_files_equal(file.path(), &working_dir.child("out.txt")); 93 93 + 94 94 + Ok(()) 95 95 + } 96 96 + 97 97 + /// Xz roundtrip using stdout 98 98 + /// Compressing: input = test.txt, output = stdout 99 99 + /// Extracting: input = test.txt.xz, output = stdout 100 100 + /// 101 101 + /// ``` bash 102 102 + /// cmprss xz test.txt > test.txt.xz 103 103 + /// cmprss xz --extract test.txt.xz > out.txt 104 104 + /// ``` 105 105 + #[test] 106 106 + fn stdout() -> Result<(), Box<dyn std::error::Error>> { 107 107 + let file = create_test_file("test.txt", "garbage data for testing")?; 108 108 + let working_dir = create_working_dir()?; 109 109 + let archive = working_dir.child("test.txt.xz"); 110 110 + archive.assert(predicate::path::missing()); 111 111 + 112 112 + // Compress file to stdout 113 113 + let mut compress = Command::cargo_bin("cmprss")?; 114 114 + compress 115 115 + .current_dir(&working_dir) 116 116 + .arg("xz") 117 117 + .arg(file.path()) 118 118 + .stdout(Stdio::from(File::create(archive.path())?)); 119 119 + compress.assert().success(); 120 120 + archive.assert(predicate::path::is_file()); 121 121 + 122 122 + // Extract file to stdout 123 123 + let mut extract = Command::cargo_bin("cmprss")?; 124 124 + extract 125 125 + .current_dir(&working_dir) 126 126 + .arg("xz") 127 127 + .arg("--ignore-stdin") 128 128 + .arg("--extract") 129 129 + .arg(archive.path()) 130 130 + .arg("out.txt"); 131 131 + extract.assert().success(); 132 132 + 133 133 + // Assert the files are identical 134 134 + assert_files_equal(file.path(), &working_dir.child("out.txt")); 135 135 + 136 136 + Ok(()) 137 137 + } 138 138 + } 139 139 + }

+131

tests/zip.rs

reviewed

··· 1 1 + use assert_cmd::prelude::*; 2 2 + use assert_fs::prelude::*; 3 3 + use predicates::prelude::*; 4 4 + use std::{path::PathBuf, process::Command}; 5 5 + 6 6 + mod common; 7 7 + use common::*; 8 8 + 9 9 + mod zip { 10 10 + use super::*; 11 11 + 12 12 + mod roundtrip { 13 13 + use super::*; 14 14 + 15 15 + /// Zip roundtrip with a single file 16 16 + /// 17 17 + /// ``` bash 18 18 + /// cmprss zip test.txt archive.zip 19 19 + /// cmprss zip --extract archive.zip . 20 20 + /// ``` 21 21 + #[test] 22 22 + fn explicit() -> Result<(), Box<dyn std::error::Error>> { 23 23 + let file = create_test_file("test.txt", "garbage data for testing")?; 24 24 + let working_dir = create_working_dir()?; 25 25 + let archive = working_dir.child("archive.zip"); 26 26 + archive.assert(predicate::path::missing()); 27 27 + 28 28 + let mut compress = Command::cargo_bin("cmprss")?; 29 29 + compress.arg("zip").arg(file.path()).arg(archive.path()); 30 30 + compress.assert().success(); 31 31 + archive.assert(predicate::path::is_file()); 32 32 + 33 33 + let mut extract = Command::cargo_bin("cmprss")?; 34 34 + extract 35 35 + .arg("zip") 36 36 + .arg("--extract") 37 37 + .arg(archive.path()) 38 38 + .arg(working_dir.path()); 39 39 + extract.assert().success(); 40 40 + 41 41 + // Assert the files are identical 42 42 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 43 43 + 44 44 + Ok(()) 45 45 + } 46 46 + 47 47 + /// Zip roundtrip with multiple files 48 48 + /// 49 49 + /// ``` bash 50 50 + /// cmprss zip test.txt test2.txt archive.zip 51 51 + /// cmprss zip --extract archive.zip . 52 52 + /// ``` 53 53 + #[test] 54 54 + fn explicit_two() -> Result<(), Box<dyn std::error::Error>> { 55 55 + let file = create_test_file("test.txt", "garbage data for testing")?; 56 56 + let file2 = create_test_file("test2.txt", "more garbage data for testing")?; 57 57 + let working_dir = create_working_dir()?; 58 58 + let archive = working_dir.child("archive.zip"); 59 59 + archive.assert(predicate::path::missing()); 60 60 + 61 61 + let mut compress = Command::cargo_bin("cmprss")?; 62 62 + compress 63 63 + .arg("zip") 64 64 + .arg(file.path()) 65 65 + .arg(file2.path()) 66 66 + .arg(archive.path()); 67 67 + compress.assert().success(); 68 68 + archive.assert(predicate::path::is_file()); 69 69 + 70 70 + let mut extract = Command::cargo_bin("cmprss")?; 71 71 + extract 72 72 + .arg("zip") 73 73 + .arg("--extract") 74 74 + .arg(archive.path()) 75 75 + .arg(working_dir.path()); 76 76 + extract.assert().success(); 77 77 + 78 78 + // Assert the files are identical 79 79 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 80 80 + assert_files_equal(file2.path(), &working_dir.child("test2.txt")); 81 81 + 82 82 + Ok(()) 83 83 + } 84 84 + 85 85 + /// Zip roundtrip with a directory 86 86 + /// 87 87 + /// ``` bash 88 88 + /// cmprss zip directory archive.zip 89 89 + /// cmprss zip --extract archive.zip output_dir 90 90 + /// ``` 91 91 + #[test] 92 92 + fn directory() -> Result<(), Box<dyn std::error::Error>> { 93 93 + let dir = create_working_dir()?; 94 94 + let file = dir.child("test.txt"); 95 95 + file.write_str("garbage data for testing")?; 96 96 + let file2 = dir.child("test2.txt"); 97 97 + file2.write_str("more garbage data for testing")?; 98 98 + 99 99 + let working_dir = create_working_dir()?; 100 100 + let archive = working_dir.child("archive.zip"); 101 101 + archive.assert(predicate::path::missing()); 102 102 + 103 103 + let mut compress = Command::cargo_bin("cmprss")?; 104 104 + compress.arg("zip").arg(dir.path()).arg(archive.path()); 105 105 + compress.assert().success(); 106 106 + archive.assert(predicate::path::is_file()); 107 107 + 108 108 + let extract_dir = working_dir.child("output"); 109 109 + std::fs::create_dir_all(extract_dir.path())?; 110 110 + 111 111 + let mut extract = Command::cargo_bin("cmprss")?; 112 112 + extract 113 113 + .arg("zip") 114 114 + .arg("--extract") 115 115 + .arg(archive.path()) 116 116 + .arg(extract_dir.path()); 117 117 + extract.assert().success(); 118 118 + 119 119 + // Assert the files are identical 120 120 + // Since the archive stores the entire directory, the extracted file is contained in the directory 121 121 + let dir_name: PathBuf = dir.path().file_name().unwrap().into(); 122 122 + assert_files_equal(file.path(), &extract_dir.child(&dir_name).child("test.txt")); 123 123 + assert_files_equal( 124 124 + file2.path(), 125 125 + &extract_dir.child(&dir_name).child("test2.txt"), 126 126 + ); 127 127 + 128 128 + Ok(()) 129 129 + } 130 130 + } 131 131 + }

+184

tests/zstd.rs

reviewed

··· 1 1 + use assert_cmd::prelude::*; 2 2 + use assert_fs::prelude::*; 3 3 + use predicates::prelude::*; 4 4 + use std::{ 5 5 + fs::File, 6 6 + process::{Command, Stdio}, 7 7 + }; 8 8 + 9 9 + mod common; 10 10 + use common::*; 11 11 + 12 12 + mod zstd { 13 13 + use super::*; 14 14 + 15 15 + mod roundtrip { 16 16 + use super::*; 17 17 + 18 18 + /// Zstd roundtrip using explicit filenames 19 19 + /// Compressing: input = test.txt, output = test.txt.zst 20 20 + /// Extracting: input = test.txt.zst, output = test.txt 21 21 + /// 22 22 + /// ``` bash 23 23 + /// cmprss zstd test.txt test.txt.zst 24 24 + /// cmprss zstd --extract --ignore-pipes test.txt.zst 25 25 + /// ``` 26 26 + #[test] 27 27 + fn explicit() -> Result<(), Box<dyn std::error::Error>> { 28 28 + let file = create_test_file("test.txt", "garbage data for testing")?; 29 29 + let working_dir = create_working_dir()?; 30 30 + let archive = working_dir.child("test.txt.zst"); 31 31 + archive.assert(predicate::path::missing()); 32 32 + 33 33 + let mut compress = Command::cargo_bin("cmprss")?; 34 34 + compress 35 35 + .current_dir(&working_dir) 36 36 + .arg("zstd") 37 37 + .arg(file.path()) 38 38 + .arg(archive.path()); 39 39 + compress.assert().success(); 40 40 + archive.assert(predicate::path::is_file()); 41 41 + 42 42 + let mut extract = Command::cargo_bin("cmprss")?; 43 43 + extract 44 44 + .current_dir(&working_dir) 45 45 + .arg("zstd") 46 46 + .arg("--ignore-pipes") 47 47 + .arg("--extract") 48 48 + .arg(archive.path()); 49 49 + extract.assert().success(); 50 50 + 51 51 + // Assert the files are identical 52 52 + assert_files_equal(file.path(), &working_dir.child("test.txt")); 53 53 + 54 54 + Ok(()) 55 55 + } 56 56 + 57 57 + /// Zstd roundtrip using stdin 58 58 + /// Compressing: input = stdin, output = test.txt.zst 59 59 + /// Extracting: input = stdin(test.txt.zst), output = test.txt 60 60 + /// 61 61 + /// ``` bash 62 62 + /// cat test.txt | cmprss zstd test.txt.zst 63 63 + /// cat test.txt.zst | cmprss zstd --extract out.txt 64 64 + /// ``` 65 65 + #[test] 66 66 + fn stdin() -> Result<(), Box<dyn std::error::Error>> { 67 67 + let file = create_test_file("test.txt", "garbage data for testing")?; 68 68 + let working_dir = create_working_dir()?; 69 69 + let archive = working_dir.child("test.txt.zst"); 70 70 + archive.assert(predicate::path::missing()); 71 71 + 72 72 + // Pipe file to stdin 73 73 + let mut compress = Command::cargo_bin("cmprss")?; 74 74 + compress 75 75 + .current_dir(&working_dir) 76 76 + .arg("zstd") 77 77 + .arg("test.txt.zst") 78 78 + .stdin(Stdio::from(File::open(file.path())?)); 79 79 + compress.assert().success(); 80 80 + archive.assert(predicate::path::is_file()); 81 81 + 82 82 + let mut extract = Command::cargo_bin("cmprss")?; 83 83 + extract 84 84 + .current_dir(&working_dir) 85 85 + .arg("zstd") 86 86 + .stdin(Stdio::from(File::open(archive.path())?)) 87 87 + .arg("--extract") 88 88 + .arg("out.txt"); 89 89 + extract.assert().success(); 90 90 + 91 91 + // Assert the files are identical 92 92 + assert_files_equal(file.path(), &working_dir.child("out.txt")); 93 93 + 94 94 + Ok(()) 95 95 + } 96 96 + 97 97 + /// Zstd roundtrip using stdout 98 98 + /// Compressing: input = test.txt, output = stdout 99 99 + /// Extracting: input = test.txt.zst, output = stdout 100 100 + /// 101 101 + /// ``` bash 102 102 + /// cmprss zstd test.txt > test.txt.zst 103 103 + /// cmprss zstd --extract test.txt.zst > out.txt 104 104 + /// ``` 105 105 + #[test] 106 106 + fn stdout() -> Result<(), Box<dyn std::error::Error>> { 107 107 + let file = create_test_file("test.txt", "garbage data for testing")?; 108 108 + let working_dir = create_working_dir()?; 109 109 + let archive = working_dir.child("test.txt.zst"); 110 110 + archive.assert(predicate::path::missing()); 111 111 + 112 112 + // Compress file to stdout 113 113 + let mut compress = Command::cargo_bin("cmprss")?; 114 114 + compress 115 115 + .current_dir(&working_dir) 116 116 + .arg("zstd") 117 117 + .arg(file.path()) 118 118 + .stdout(Stdio::from(File::create(archive.path())?)); 119 119 + compress.assert().success(); 120 120 + archive.assert(predicate::path::is_file()); 121 121 + 122 122 + let output = working_dir.child("out.txt"); 123 123 + output.assert(predicate::path::missing()); 124 124 + 125 125 + let mut extract = Command::cargo_bin("cmprss")?; 126 126 + extract 127 127 + .current_dir(&working_dir) 128 128 + .arg("zstd") 129 129 + .arg("--extract") 130 130 + .arg(archive.path()) 131 131 + .stdout(Stdio::from(File::create(output.path())?)); 132 132 + extract.assert().success(); 133 133 + output.assert(predicate::path::is_file()); 134 134 + 135 135 + // Assert the files are identical 136 136 + assert_files_equal(file.path(), output.path()); 137 137 + 138 138 + Ok(()) 139 139 + } 140 140 + 141 141 + /// Zstd roundtrip with compression level 142 142 + /// Compressing: input = test.txt, output = test.txt.zst, level = 9 143 143 + /// Extracting: input = test.txt.zst, output = test.txt 144 144 + /// 145 145 + /// ``` bash 146 146 + /// cmprss zstd --level 9 test.txt test.txt.zst 147 147 + /// cmprss zstd --extract test.txt.zst test.txt 148 148 + /// ``` 149 149 + #[test] 150 150 + fn with_level() -> Result<(), Box<dyn std::error::Error>> { 151 151 + let file = create_test_file("test.txt", "garbage data for testing")?; 152 152 + let working_dir = create_working_dir()?; 153 153 + let archive = working_dir.child("test.txt.zst"); 154 154 + archive.assert(predicate::path::missing()); 155 155 + 156 156 + let mut compress = Command::cargo_bin("cmprss")?; 157 157 + compress 158 158 + .current_dir(&working_dir) 159 159 + .arg("zstd") 160 160 + .arg("--level") 161 161 + .arg("9") 162 162 + .arg(file.path()) 163 163 + .arg(archive.path()); 164 164 + compress.assert().success(); 165 165 + archive.assert(predicate::path::is_file()); 166 166 + 167 167 + let output = working_dir.child("test.txt"); 168 168 + 169 169 + let mut extract = Command::cargo_bin("cmprss")?; 170 170 + extract 171 171 + .current_dir(&working_dir) 172 172 + .arg("zstd") 173 173 + .arg("--extract") 174 174 + .arg(archive.path()) 175 175 + .arg(output.path()); 176 176 + extract.assert().success(); 177 177 + 178 178 + // Assert the files are identical 179 179 + assert_files_equal(file.path(), output.path()); 180 180 + 181 181 + Ok(()) 182 182 + } 183 183 + } 184 184 + }