use std::io; use test_case::test_case; use super::B3Digest; use super::BlobService; use super::MemoryBlobService; use super::SledBlobService; use crate::tests::fixtures; // TODO: avoid having to define all different services we test against for all functions. // maybe something like rstest can be used? fn gen_memory_blob_service() -> impl BlobService { MemoryBlobService::default() } fn gen_sled_blob_service() -> impl BlobService { SledBlobService::new_temporary().unwrap() } // TODO: add GRPC blob service here. /// Using [BlobService::has] on a non-existing blob should return false #[test_case(gen_memory_blob_service(); "memory")] #[test_case(gen_sled_blob_service(); "sled")] fn has_nonexistent_false(blob_service: impl BlobService) { assert_eq!( blob_service .has(&fixtures::BLOB_A_DIGEST) .expect("must not fail"), false ); } /// Trying to read a non-existing blob should return a None instead of a reader. #[test_case(gen_memory_blob_service(); "memory")] #[test_case(gen_sled_blob_service(); "sled")] fn not_found_read(blob_service: impl BlobService) { assert!(blob_service .open_read(&fixtures::BLOB_A_DIGEST) .expect("must not fail") .is_none()) } /// Put a blob in the store, check has, get it back. /// We test both with small and big blobs. #[test_case(gen_memory_blob_service(), &fixtures::BLOB_A, &fixtures::BLOB_A_DIGEST; "memory-small")] #[test_case(gen_sled_blob_service(), &fixtures::BLOB_A, &fixtures::BLOB_A_DIGEST; "sled-small")] #[test_case(gen_memory_blob_service(), &fixtures::BLOB_B, &fixtures::BLOB_B_DIGEST; "memory-big")] #[test_case(gen_sled_blob_service(), &fixtures::BLOB_B, &fixtures::BLOB_B_DIGEST; "sled-big")] fn put_has_get(blob_service: impl BlobService, blob_contents: &[u8], blob_digest: &B3Digest) { let mut w = blob_service.open_write(); let l = io::copy(&mut io::Cursor::new(blob_contents), &mut w).expect("copy must succeed"); assert_eq!( blob_contents.len(), l as usize, "written bytes must match blob length" ); let digest = w.close().expect("close must succeed"); assert_eq!(*blob_digest, digest, "returned digest must be correct"); assert_eq!( blob_service.has(blob_digest).expect("must not fail"), true, "blob service should now have the blob" ); let mut r = blob_service .open_read(blob_digest) .expect("open_read must succeed") .expect("must be some"); let mut buf: Vec = Vec::new(); let l = io::copy(&mut r, &mut buf).expect("copy must succeed"); assert_eq!( blob_contents.len(), l as usize, "read bytes must match blob length" ); assert_eq!(blob_contents, buf, "read blob contents must match"); } /// Put a blob in the store, and seek inside it a bit. #[test_case(gen_memory_blob_service(); "memory")] #[test_case(gen_sled_blob_service(); "sled")] fn put_seek(blob_service: impl BlobService) { let mut w = blob_service.open_write(); io::copy(&mut io::Cursor::new(&fixtures::BLOB_B.to_vec()), &mut w).expect("copy must succeed"); w.close().expect("close must succeed"); // open a blob for reading let mut r = blob_service .open_read(&fixtures::BLOB_B_DIGEST) .expect("open_read must succeed") .expect("must be some"); let mut pos: u64 = 0; // read the first 10 bytes, they must match the data in the fixture. { let mut buf = [0; 10]; r.read_exact(&mut buf).expect("must succeed"); assert_eq!( &fixtures::BLOB_B[pos as usize..pos as usize + buf.len()], buf, "expected first 10 bytes to match" ); pos += buf.len() as u64; } // seek by 0 bytes, using SeekFrom::Start. let p = r .seek(io::SeekFrom::Start(pos as u64)) .expect("must not fail"); assert_eq!(pos, p); // read the next 10 bytes, they must match the data in the fixture. { let mut buf = [0; 10]; r.read_exact(&mut buf).expect("must succeed"); assert_eq!( &fixtures::BLOB_B[pos as usize..pos as usize + buf.len()], buf, "expected data to match" ); pos += buf.len() as u64; } // seek by 5 bytes, using SeekFrom::Start. let p = r .seek(io::SeekFrom::Start(pos as u64 + 5)) .expect("must not fail"); pos += 5; assert_eq!(pos, p); // read the next 10 bytes, they must match the data in the fixture. { let mut buf = [0; 10]; r.read_exact(&mut buf).expect("must succeed"); assert_eq!( &fixtures::BLOB_B[pos as usize..pos as usize + buf.len()], buf, "expected data to match" ); pos += buf.len() as u64; } // seek by 12345 bytes, using SeekFrom:: let p = r.seek(io::SeekFrom::Current(12345)).expect("must not fail"); pos += 12345; assert_eq!(pos, p); // read the next 10 bytes, they must match the data in the fixture. { let mut buf = [0; 10]; r.read_exact(&mut buf).expect("must succeed"); assert_eq!( &fixtures::BLOB_B[pos as usize..pos as usize + buf.len()], buf, "expected data to match" ); #[allow(unused_assignments)] { pos += buf.len() as u64; } } // seeking to the end is okay… let p = r .seek(io::SeekFrom::Start(fixtures::BLOB_B.len() as u64)) .expect("must not fail"); pos = fixtures::BLOB_B.len() as u64; assert_eq!(pos, p); { // but it returns no more data. let mut buf: Vec = Vec::new(); r.read_to_end(&mut buf).expect("must not fail"); assert!(buf.is_empty(), "expected no more data to be read"); } // seeking past the end… match r.seek(io::SeekFrom::Start(fixtures::BLOB_B.len() as u64 + 1)) { // should either be ok, but then return 0 bytes. // this matches the behaviour or a Cursor>. Ok(_pos) => { let mut buf: Vec = Vec::new(); r.read_to_end(&mut buf).expect("must not fail"); assert!(buf.is_empty(), "expected no more data to be read"); } // or not be okay. Err(_) => {} } // TODO: this is only broken for the gRPC version // We expect seeking backwards or relative to the end to fail. // r.seek(io::SeekFrom::Current(-1)) // .expect_err("SeekFrom::Current(-1) expected to fail"); // r.seek(io::SeekFrom::Start(pos - 1)) // .expect_err("SeekFrom::Start(pos-1) expected to fail"); // r.seek(io::SeekFrom::End(0)) // .expect_err("SeekFrom::End(_) expected to fail"); }