2023-02-13 16:44:26 +01:00
|
|
|
use crate::blobservice::BlobService;
|
|
|
|
use crate::chunkservice::ChunkService;
|
|
|
|
use crate::directoryservice::DirectoryService;
|
|
|
|
use crate::nar::NARRenderer;
|
2023-01-29 20:48:23 +01:00
|
|
|
use crate::proto;
|
|
|
|
use crate::proto::DirectoryNode;
|
|
|
|
use crate::proto::FileNode;
|
|
|
|
use crate::proto::SymlinkNode;
|
2023-02-27 09:12:09 +01:00
|
|
|
use crate::tests::fixtures::*;
|
2023-02-27 08:59:45 +01:00
|
|
|
use crate::tests::utils::*;
|
2023-01-29 20:48:23 +01:00
|
|
|
|
2023-02-13 16:44:26 +01:00
|
|
|
#[test]
|
2023-02-16 17:38:10 +01:00
|
|
|
fn single_symlink() {
|
2023-02-13 16:44:26 +01:00
|
|
|
let renderer = NARRenderer::new(
|
2023-03-01 18:55:51 +01:00
|
|
|
gen_blob_service(),
|
|
|
|
gen_chunk_service(),
|
|
|
|
gen_directory_service(),
|
2023-02-13 16:44:26 +01:00
|
|
|
);
|
|
|
|
// don't put anything in the stores, as we don't actually do any requests.
|
|
|
|
|
2023-01-29 20:48:23 +01:00
|
|
|
let mut buf: Vec<u8> = vec![];
|
|
|
|
|
2023-02-13 16:44:26 +01:00
|
|
|
renderer
|
|
|
|
.write_nar(
|
|
|
|
&mut buf,
|
2023-03-16 23:54:29 +01:00
|
|
|
&crate::proto::node::Node::Symlink(SymlinkNode {
|
2023-02-13 16:44:26 +01:00
|
|
|
name: "doesntmatter".to_string(),
|
|
|
|
target: "/nix/store/somewhereelse".to_string(),
|
|
|
|
}),
|
|
|
|
)
|
|
|
|
.expect("must succeed");
|
2023-01-29 20:48:23 +01:00
|
|
|
|
2023-02-27 10:49:42 +01:00
|
|
|
assert_eq!(buf, NAR_CONTENTS_SYMLINK.to_vec());
|
2023-01-29 20:48:23 +01:00
|
|
|
}
|
|
|
|
|
2023-02-16 17:11:09 +01:00
|
|
|
/// Make sure the NARRenderer fails if the blob size in the proto node doesn't
|
|
|
|
/// match what's in the store.
|
|
|
|
#[test]
|
|
|
|
fn single_file_missing_blob() {
|
|
|
|
let renderer = NARRenderer::new(
|
2023-03-01 18:55:51 +01:00
|
|
|
gen_blob_service(),
|
|
|
|
gen_chunk_service(),
|
|
|
|
gen_directory_service(),
|
2023-02-16 17:11:09 +01:00
|
|
|
);
|
|
|
|
let mut buf: Vec<u8> = vec![];
|
|
|
|
|
|
|
|
let e = renderer
|
|
|
|
.write_nar(
|
|
|
|
&mut buf,
|
2023-03-16 23:54:29 +01:00
|
|
|
&crate::proto::node::Node::File(FileNode {
|
2023-02-16 17:11:09 +01:00
|
|
|
name: "doesntmatter".to_string(),
|
|
|
|
digest: HELLOWORLD_BLOB_DIGEST.to_vec(),
|
|
|
|
size: HELLOWORLD_BLOB_CONTENTS.len() as u32,
|
|
|
|
executable: false,
|
|
|
|
}),
|
|
|
|
)
|
|
|
|
.expect_err("must fail");
|
|
|
|
|
|
|
|
if let crate::nar::RenderError::BlobNotFound(actual_digest, _) = e {
|
|
|
|
assert_eq!(HELLOWORLD_BLOB_DIGEST.to_vec(), actual_digest);
|
|
|
|
} else {
|
|
|
|
panic!("unexpected error")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Make sure the NAR Renderer fails if the returned blob meta has another size
|
|
|
|
/// than specified in the proto node.
|
|
|
|
#[test]
|
|
|
|
fn single_file_wrong_blob_size() {
|
2023-03-01 18:55:51 +01:00
|
|
|
let blob_service = gen_blob_service();
|
|
|
|
let chunk_service = gen_chunk_service();
|
2023-02-16 17:11:09 +01:00
|
|
|
|
|
|
|
// insert blob and chunk into the stores
|
|
|
|
chunk_service
|
|
|
|
.put(HELLOWORLD_BLOB_CONTENTS.to_vec())
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
blob_service
|
|
|
|
.put(
|
|
|
|
&HELLOWORLD_BLOB_DIGEST,
|
|
|
|
proto::BlobMeta {
|
|
|
|
chunks: vec![proto::blob_meta::ChunkMeta {
|
|
|
|
digest: HELLOWORLD_BLOB_DIGEST.to_vec(),
|
|
|
|
size: HELLOWORLD_BLOB_CONTENTS.len() as u32,
|
|
|
|
}],
|
|
|
|
..Default::default()
|
|
|
|
},
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
|
2023-03-01 18:55:51 +01:00
|
|
|
let renderer = NARRenderer::new(blob_service, chunk_service, gen_directory_service());
|
2023-02-16 17:11:09 +01:00
|
|
|
let mut buf: Vec<u8> = vec![];
|
|
|
|
|
|
|
|
let e = renderer
|
|
|
|
.write_nar(
|
|
|
|
&mut buf,
|
2023-03-16 23:54:29 +01:00
|
|
|
&crate::proto::node::Node::File(FileNode {
|
2023-02-16 17:11:09 +01:00
|
|
|
name: "doesntmatter".to_string(),
|
|
|
|
digest: HELLOWORLD_BLOB_DIGEST.to_vec(),
|
|
|
|
size: 42, // <- note the wrong size here!
|
|
|
|
executable: false,
|
|
|
|
}),
|
|
|
|
)
|
|
|
|
.expect_err("must fail");
|
|
|
|
|
|
|
|
if let crate::nar::RenderError::UnexpectedBlobMeta(digest, _, expected_size, actual_size) = e {
|
|
|
|
assert_eq!(
|
|
|
|
digest,
|
|
|
|
HELLOWORLD_BLOB_DIGEST.to_vec(),
|
|
|
|
"expect digest to match"
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
expected_size, 42,
|
|
|
|
"expected expected size to be what's passed in the request"
|
|
|
|
);
|
|
|
|
assert_eq!(
|
|
|
|
actual_size,
|
|
|
|
HELLOWORLD_BLOB_CONTENTS.len() as u32,
|
|
|
|
"expected actual size to be correct"
|
|
|
|
);
|
|
|
|
} else {
|
|
|
|
panic!("unexpected error")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-02-13 16:44:26 +01:00
|
|
|
#[test]
|
2023-02-16 17:38:10 +01:00
|
|
|
fn single_file() {
|
2023-03-01 18:55:51 +01:00
|
|
|
let blob_service = gen_blob_service();
|
|
|
|
let chunk_service = gen_chunk_service();
|
2023-02-13 16:44:26 +01:00
|
|
|
|
|
|
|
chunk_service
|
|
|
|
.put(HELLOWORLD_BLOB_CONTENTS.to_vec())
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
blob_service
|
|
|
|
.put(
|
|
|
|
&HELLOWORLD_BLOB_DIGEST,
|
|
|
|
proto::BlobMeta {
|
|
|
|
chunks: vec![proto::blob_meta::ChunkMeta {
|
|
|
|
digest: HELLOWORLD_BLOB_DIGEST.to_vec(),
|
|
|
|
size: HELLOWORLD_BLOB_CONTENTS.len() as u32,
|
|
|
|
}],
|
|
|
|
..Default::default()
|
|
|
|
},
|
|
|
|
)
|
|
|
|
.unwrap();
|
|
|
|
|
2023-03-01 18:55:51 +01:00
|
|
|
let renderer = NARRenderer::new(blob_service, chunk_service, gen_directory_service());
|
2023-01-29 20:48:23 +01:00
|
|
|
let mut buf: Vec<u8> = vec![];
|
2023-02-13 16:44:26 +01:00
|
|
|
|
|
|
|
renderer
|
|
|
|
.write_nar(
|
|
|
|
&mut buf,
|
2023-03-16 23:54:29 +01:00
|
|
|
&crate::proto::node::Node::File(FileNode {
|
2023-02-13 16:44:26 +01:00
|
|
|
name: "doesntmatter".to_string(),
|
|
|
|
digest: HELLOWORLD_BLOB_DIGEST.to_vec(),
|
|
|
|
size: HELLOWORLD_BLOB_CONTENTS.len() as u32,
|
|
|
|
executable: false,
|
|
|
|
}),
|
|
|
|
)
|
|
|
|
.expect("must succeed");
|
2023-01-29 20:48:23 +01:00
|
|
|
|
2023-02-27 10:49:42 +01:00
|
|
|
assert_eq!(buf, NAR_CONTENTS_HELLOWORLD.to_vec());
|
2023-01-29 20:48:23 +01:00
|
|
|
}
|
|
|
|
|
2023-02-13 16:44:26 +01:00
|
|
|
#[test]
|
2023-02-16 17:38:10 +01:00
|
|
|
fn test_complicated() {
|
2023-03-01 18:55:51 +01:00
|
|
|
let blob_service = gen_blob_service();
|
|
|
|
let chunk_service = gen_chunk_service();
|
|
|
|
let directory_service = gen_directory_service();
|
2023-02-13 16:44:26 +01:00
|
|
|
|
|
|
|
// put all data into the stores.
|
2023-02-27 12:58:29 +01:00
|
|
|
let digest = chunk_service.put(EMPTY_BLOB_CONTENTS.to_vec()).unwrap();
|
|
|
|
|
|
|
|
blob_service
|
|
|
|
.put(
|
|
|
|
&digest,
|
|
|
|
proto::BlobMeta {
|
|
|
|
chunks: vec![proto::blob_meta::ChunkMeta {
|
|
|
|
digest: digest.to_vec(),
|
|
|
|
size: EMPTY_BLOB_CONTENTS.len() as u32,
|
|
|
|
}],
|
|
|
|
..Default::default()
|
|
|
|
},
|
|
|
|
)
|
|
|
|
.unwrap();
|
2023-02-13 16:44:26 +01:00
|
|
|
|
|
|
|
directory_service.put(DIRECTORY_WITH_KEEP.clone()).unwrap();
|
|
|
|
directory_service
|
|
|
|
.put(DIRECTORY_COMPLICATED.clone())
|
|
|
|
.unwrap();
|
|
|
|
|
|
|
|
let renderer = NARRenderer::new(blob_service, chunk_service, directory_service);
|
2023-01-29 20:48:23 +01:00
|
|
|
let mut buf: Vec<u8> = vec![];
|
2023-02-13 16:44:26 +01:00
|
|
|
|
|
|
|
renderer
|
|
|
|
.write_nar(
|
|
|
|
&mut buf,
|
2023-03-16 23:54:29 +01:00
|
|
|
&crate::proto::node::Node::Directory(DirectoryNode {
|
2023-02-13 16:44:26 +01:00
|
|
|
name: "doesntmatter".to_string(),
|
2023-03-16 00:01:30 +01:00
|
|
|
digest: DIRECTORY_COMPLICATED.digest().to_vec(),
|
2023-02-13 16:44:26 +01:00
|
|
|
size: DIRECTORY_COMPLICATED.size(),
|
|
|
|
}),
|
|
|
|
)
|
|
|
|
.expect("must succeed");
|
2023-01-29 20:48:23 +01:00
|
|
|
|
2023-02-27 10:49:42 +01:00
|
|
|
assert_eq!(buf, NAR_CONTENTS_COMPLICATED.to_vec());
|
2023-01-29 20:48:23 +01:00
|
|
|
}
|