1#![forbid(unsafe_code)]
2#![deny(missing_docs)]
3#![doc = "Optional consumer-side adapter from Eggpack ReleaseManifest v1 to Eggup inputs."]
4
5use eggpack_manifest::{ArtifactForm, ReleaseManifest, MAX_DOCUMENT_BYTES};
6use eggup_acquisition::{AcquisitionRequest, FetchLimits};
7use eggup_archive::{ArchiveFormat, ArchiveLimits, ArchiveMember, ArchivePlan, BoundMember};
8use eggup_core::{
9 ArtifactMember, ArtifactSet, BoundSources, InstallPlan, IntegrityRequirement, MemberId,
10 PermissionsIntent, ProductId, ReleaseId,
11};
12use std::{
13 collections::{HashMap, HashSet},
14 fmt, fs,
15 path::{Path, PathBuf},
16};
17
18#[derive(Debug)]
20#[non_exhaustive]
21pub enum AdapterError {
22 InvalidManifest,
24 TargetNotFound,
26 MapMismatch(&'static str),
28 CallerLimitTooSmall(String),
30 InvalidAcquiredFile(String),
32 ArchiveExtractionRequired,
34 UnsupportedArchiveFormat,
36 Eggup(String),
38}
39
40impl fmt::Display for AdapterError {
41 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
42 match self {
43 Self::InvalidManifest => f.write_str("invalid manifest or identity"),
44 Self::TargetNotFound => f.write_str("canonical target not found"),
45 Self::MapMismatch(kind) => write!(f, "{kind} map does not exactly match manifest"),
46 Self::CallerLimitTooSmall(name) => {
47 write!(f, "caller byte limit is below manifest size for {name}")
48 }
49 Self::InvalidAcquiredFile(name) => write!(f, "acquired file is invalid for {name}"),
50 Self::ArchiveExtractionRequired => f.write_str("archive extraction is required"),
51 Self::UnsupportedArchiveFormat => {
52 f.write_str("artifact name does not name a supported archive format")
53 }
54 Self::Eggup(detail) => write!(f, "Eggup input construction failed: {detail}"),
55 }
56 }
57}
58impl std::error::Error for AdapterError {}
59
60pub const MAX_MANIFEST_BYTES: usize = MAX_DOCUMENT_BYTES;
62
63#[derive(Debug, Clone, PartialEq, Eq)]
65pub struct ArtifactRequirement {
66 pub artifact_name: String,
68 pub exact_size: u64,
70 pub sha256: [u8; 32],
72 pub member_id: MemberId,
74 pub destination: String,
76}
77
78#[derive(Debug, Clone, PartialEq, Eq)]
80pub struct ArchiveMemberRequirement {
81 pub source: String,
83 pub install: String,
85 pub exact_size: u64,
87 pub sha256: [u8; 32],
89}
90
91#[derive(Debug, Clone, PartialEq, Eq)]
93pub enum ManifestProjection {
94 Installable {
96 product: ProductId,
98 release: ReleaseId,
100 target: String,
102 artifacts: Vec<ArtifactRequirement>,
104 },
105 Archive {
107 product: ProductId,
109 release: ReleaseId,
111 target: String,
113 artifact_name: String,
115 exact_size: u64,
117 sha256: [u8; 32],
119 members: Vec<ArchiveMemberRequirement>,
121 },
122}
123
124impl ManifestProjection {
125 fn installable(
126 &self,
127 ) -> Result<(&ProductId, &ReleaseId, &[ArtifactRequirement]), AdapterError> {
128 match self {
129 Self::Installable {
130 product,
131 release,
132 artifacts,
133 ..
134 } => Ok((product, release, artifacts)),
135 Self::Archive { .. } => Err(AdapterError::ArchiveExtractionRequired),
136 }
137 }
138
139 pub fn default_destinations(&self) -> Result<HashMap<MemberId, String>, AdapterError> {
148 match self {
149 Self::Installable { artifacts, .. } => Ok(artifacts
150 .iter()
151 .map(|a| (a.member_id.clone(), a.destination.clone()))
152 .collect()),
153 Self::Archive { members, .. } => members
154 .iter()
155 .map(|m| {
156 let id = MemberId::new(m.install.clone())
157 .map_err(|e| AdapterError::Eggup(e.to_string()))?;
158 Ok((id, m.install.clone()))
159 })
160 .collect(),
161 }
162 }
163
164 pub fn bind_requests(
166 &self,
167 requests: HashMap<String, AcquisitionRequest>,
168 baseline: FetchLimits,
169 ) -> Result<Vec<PlannedAcquisition>, AdapterError> {
170 baseline
171 .validate()
172 .map_err(|e| AdapterError::Eggup(e.to_string()))?;
173 let requirements = match self {
174 Self::Installable { artifacts, .. } => artifacts
175 .iter()
176 .map(|a| {
177 (
178 a.artifact_name.clone(),
179 a.exact_size,
180 a.sha256,
181 a.member_id.clone(),
182 )
183 })
184 .collect::<Vec<_>>(),
185 Self::Archive {
186 artifact_name,
187 exact_size,
188 sha256,
189 ..
190 } => vec![(
191 artifact_name.clone(),
192 *exact_size,
193 *sha256,
194 MemberId::new(artifact_name.clone())
195 .map_err(|e| AdapterError::Eggup(e.to_string()))?,
196 )],
197 };
198 if requests.len() != requirements.len()
199 || requirements.iter().any(|(n, ..)| !requests.contains_key(n))
200 {
201 return Err(AdapterError::MapMismatch("acquisition request"));
202 }
203 requirements
204 .into_iter()
205 .map(|(name, size, sha, member)| {
206 if baseline.max_artifact_bytes < size {
207 return Err(AdapterError::CallerLimitTooSmall(name.clone()));
208 }
209 Ok(PlannedAcquisition {
210 artifact_name: name.clone(),
211 request: requests.get(&name).expect("checked map").clone(),
212 limits: FetchLimits {
213 max_artifact_bytes: size,
214 ..baseline
215 },
216 exact_size: size,
217 sha256: sha,
218 member_id: member,
219 })
220 })
221 .collect()
222 }
223
224 pub fn materialize_artifact_set_with_destinations(
239 &self,
240 acquired: HashMap<String, PathBuf>,
241 destinations: HashMap<MemberId, String>,
242 permissions: HashMap<MemberId, PermissionsIntent>,
243 ) -> Result<ArtifactSet, AdapterError> {
244 let (_, _, reqs) = self.installable()?;
245 if acquired.len() != reqs.len()
246 || reqs
247 .iter()
248 .any(|r| !acquired.contains_key(&r.artifact_name))
249 {
250 return Err(AdapterError::MapMismatch("acquired path"));
251 }
252 if destinations.len() != reqs.len()
253 || reqs
254 .iter()
255 .any(|r| !destinations.contains_key(&r.member_id))
256 {
257 return Err(AdapterError::MapMismatch("destinations"));
258 }
259 if permissions.len() != reqs.len()
260 || reqs.iter().any(|r| !permissions.contains_key(&r.member_id))
261 {
262 return Err(AdapterError::MapMismatch("permissions"));
263 }
264 let mut members = Vec::with_capacity(reqs.len());
265 for r in reqs {
266 let path = acquired.get(&r.artifact_name).expect("checked map");
267 if !path.is_absolute() {
268 return Err(AdapterError::InvalidAcquiredFile(r.artifact_name.clone()));
269 }
270 let meta = fs::symlink_metadata(path)
271 .map_err(|_| AdapterError::InvalidAcquiredFile(r.artifact_name.clone()))?;
272 if !meta.file_type().is_file() || meta.len() != r.exact_size {
273 return Err(AdapterError::InvalidAcquiredFile(r.artifact_name.clone()));
274 }
275 let destination = destinations.get(&r.member_id).expect("checked map");
276 members.push(
277 ArtifactMember::new(r.member_id.clone(), path, destination)
278 .map_err(|e| AdapterError::Eggup(e.to_string()))?
279 .with_permissions(*permissions.get(&r.member_id).expect("checked map"))
280 .with_integrity(IntegrityRequirement::Sha256(r.sha256)),
281 );
282 }
283 let mut seen = HashSet::with_capacity(members.len());
284 for member in &members {
285 if !seen.insert(member.destination().to_path_buf()) {
286 return Err(AdapterError::MapMismatch("destinations"));
287 }
288 }
289 ArtifactSet::new(members).map_err(|e| AdapterError::Eggup(e.to_string()))
290 }
291
292 pub fn materialize_artifact_set(
299 &self,
300 acquired: HashMap<String, PathBuf>,
301 permissions: HashMap<MemberId, PermissionsIntent>,
302 ) -> Result<ArtifactSet, AdapterError> {
303 let destinations = self.default_destinations()?;
304 self.materialize_artifact_set_with_destinations(acquired, destinations, permissions)
305 }
306}
307
308#[derive(Debug, Clone)]
310pub struct PlannedAcquisition {
311 pub artifact_name: String,
313 pub request: AcquisitionRequest,
315 pub limits: FetchLimits,
317 pub exact_size: u64,
319 pub sha256: [u8; 32],
321 pub member_id: MemberId,
323}
324
325pub fn project(
327 manifest: &ReleaseManifest,
328 canonical_target: &str,
329) -> Result<ManifestProjection, AdapterError> {
330 manifest
331 .validate()
332 .map_err(|_| AdapterError::InvalidManifest)?;
333 let target = manifest
334 .target(canonical_target)
335 .map_err(|_| AdapterError::TargetNotFound)?;
336 let product = ProductId::new(manifest.product_id.clone())
337 .map_err(|e| AdapterError::Eggup(e.to_string()))?;
338 let release = ReleaseId::new(manifest.release_id.clone())
339 .map_err(|e| AdapterError::Eggup(e.to_string()))?;
340 let common = (product, release, target.target.clone());
341 match &target.form {
342 ArtifactForm::Direct { artifact, install } => Ok(ManifestProjection::Installable {
343 product: common.0,
344 release: common.1,
345 target: common.2,
346 artifacts: vec![ArtifactRequirement {
347 artifact_name: artifact.name.clone(),
348 exact_size: artifact.size,
349 sha256: artifact
350 .sha256_bytes()
351 .map_err(|_| AdapterError::InvalidManifest)?,
352 member_id: MemberId::new(install.clone())
353 .map_err(|e| AdapterError::Eggup(e.to_string()))?,
354 destination: install.clone(),
355 }],
356 }),
357 ArtifactForm::Bundle { entries } => Ok(ManifestProjection::Installable {
358 product: common.0,
359 release: common.1,
360 target: common.2,
361 artifacts: entries
362 .iter()
363 .map(|e| {
364 Ok(ArtifactRequirement {
365 artifact_name: e.artifact.name.clone(),
366 exact_size: e.artifact.size,
367 sha256: e
368 .artifact
369 .sha256_bytes()
370 .map_err(|_| AdapterError::InvalidManifest)?,
371 member_id: MemberId::new(e.install.clone())
372 .map_err(|x| AdapterError::Eggup(x.to_string()))?,
373 destination: e.install.clone(),
374 })
375 })
376 .collect::<Result<_, AdapterError>>()?,
377 }),
378 ArtifactForm::Archive { artifact, members } => Ok(ManifestProjection::Archive {
379 product: common.0,
380 release: common.1,
381 target: common.2,
382 artifact_name: artifact.name.clone(),
383 exact_size: artifact.size,
384 sha256: artifact
385 .sha256_bytes()
386 .map_err(|_| AdapterError::InvalidManifest)?,
387 members: members
388 .iter()
389 .map(|m| {
390 Ok(ArchiveMemberRequirement {
391 source: m.source.clone(),
392 install: m.install.clone(),
393 exact_size: m.bytes.size,
394 sha256: m
395 .bytes
396 .sha256_bytes()
397 .map_err(|_| AdapterError::InvalidManifest)?,
398 })
399 })
400 .collect::<Result<_, AdapterError>>()?,
401 }),
402 }
403}
404
405pub fn project_json(
410 input: &[u8],
411 canonical_target: &str,
412) -> Result<ManifestProjection, AdapterError> {
413 if input.len() > MAX_MANIFEST_BYTES {
414 return Err(AdapterError::InvalidManifest);
415 }
416 let json = std::str::from_utf8(input).map_err(|_| AdapterError::InvalidManifest)?;
417 let manifest = ReleaseManifest::from_json(json).map_err(|_| AdapterError::InvalidManifest)?;
418 project(&manifest, canonical_target)
419}
420
421pub fn install_ids(
423 projection: &ManifestProjection,
424) -> Result<(&ProductId, &ReleaseId), AdapterError> {
425 let (product, release, _) = projection.installable()?;
426 Ok((product, release))
427}
428
429pub fn archive_format_for_name(file_name: &str) -> Result<ArchiveFormat, AdapterError> {
459 if file_name.is_empty() || !file_name.is_ascii() {
460 return Err(AdapterError::UnsupportedArchiveFormat);
461 }
462 let lower = file_name.to_ascii_lowercase();
463 if lower.ends_with(".tar.gz") || lower.ends_with(".tgz") {
464 Ok(ArchiveFormat::TarGz)
465 } else if lower.ends_with(".zip") {
466 Ok(ArchiveFormat::Zip)
467 } else {
468 Err(AdapterError::UnsupportedArchiveFormat)
469 }
470}
471
472pub fn validate_acquired_archive(
482 projection: &ManifestProjection,
483 acquired_archive_path: &Path,
484) -> Result<(), AdapterError> {
485 use sha2::{Digest, Sha256};
486 use std::io::Read;
487 let (artifact_name, exact_size, sha256) = match projection {
488 ManifestProjection::Archive {
489 artifact_name,
490 exact_size,
491 sha256,
492 ..
493 } => (artifact_name, *exact_size, *sha256),
494 _ => return Err(AdapterError::ArchiveExtractionRequired),
495 };
496 if !acquired_archive_path.is_absolute() {
497 return Err(AdapterError::InvalidAcquiredFile(artifact_name.clone()));
498 }
499 let meta = fs::symlink_metadata(acquired_archive_path)
500 .map_err(|_| AdapterError::InvalidAcquiredFile(artifact_name.clone()))?;
501 if !meta.file_type().is_file() || meta.len() != exact_size {
502 return Err(AdapterError::InvalidAcquiredFile(artifact_name.clone()));
503 }
504 let mut file = fs::File::open(acquired_archive_path)
505 .map_err(|_| AdapterError::InvalidAcquiredFile(artifact_name.clone()))?;
506 let mut hasher = Sha256::new();
507 let mut chunk = [0u8; 16 * 1024];
508 loop {
509 let read = file
510 .read(&mut chunk)
511 .map_err(|_| AdapterError::InvalidAcquiredFile(artifact_name.clone()))?;
512 if read == 0 {
513 break;
514 }
515 hasher.update(&chunk[..read]);
516 }
517 let digest: [u8; 32] = hasher.finalize().into();
518 if digest != sha256 {
519 return Err(AdapterError::InvalidAcquiredFile(artifact_name.clone()));
520 }
521 Ok(())
522}
523
524pub fn archive_plan_for(
535 projection: &ManifestProjection,
536 archive_format: ArchiveFormat,
537 acquired_archive_path: &Path,
538 limits: ArchiveLimits,
539) -> Result<ArchivePlan, AdapterError> {
540 let members = match projection {
541 ManifestProjection::Archive { members, .. } => members,
542 _ => return Err(AdapterError::ArchiveExtractionRequired),
543 };
544 let mut declared = Vec::with_capacity(members.len());
545 for m in members {
546 let member = ArchiveMember::new(
547 m.source.clone(),
548 m.install.clone(),
549 Some(m.exact_size),
550 Some(m.sha256),
551 )
552 .map_err(|e| AdapterError::Eggup(e.to_string()))?;
553 declared.push(member);
554 }
555 ArchivePlan::new(acquired_archive_path, archive_format, declared, limits)
556 .map_err(|e| AdapterError::Eggup(e.to_string()))
557}
558
559pub fn core_plan_for_archive_with_destinations(
584 projection: &ManifestProjection,
585 extraction_root: &Path,
586 destination_root: &Path,
587 destinations: HashMap<MemberId, String>,
588 permissions: HashMap<MemberId, PermissionsIntent>,
589) -> Result<InstallPlan, AdapterError> {
590 let (product, release, members) = match projection {
591 ManifestProjection::Archive {
592 product,
593 release,
594 members,
595 ..
596 } => (product, release, members),
597 _ => return Err(AdapterError::ArchiveExtractionRequired),
598 };
599 if destinations.len() != members.len() {
600 return Err(AdapterError::MapMismatch("destinations"));
601 }
602 if permissions.len() != members.len() {
603 return Err(AdapterError::MapMismatch("permissions"));
604 }
605 let mut artifacts = Vec::with_capacity(members.len());
606 for m in members {
607 let id =
608 MemberId::new(m.install.clone()).map_err(|e| AdapterError::Eggup(e.to_string()))?;
609 let destination = destinations
610 .get(&id)
611 .ok_or(AdapterError::MapMismatch("destinations"))?;
612 let advisory = extraction_root.join(&m.install);
613 let permissions_intent = permissions
614 .get(&id)
615 .copied()
616 .ok_or(AdapterError::MapMismatch("permissions"))?;
617 let member = ArtifactMember::new(id.clone(), &advisory, destination)
618 .map_err(|e| AdapterError::Eggup(e.to_string()))?
619 .with_permissions(permissions_intent)
620 .with_integrity(IntegrityRequirement::Sha256(m.sha256));
621 artifacts.push(member);
622 }
623 let mut seen = HashSet::with_capacity(artifacts.len());
624 for member in &artifacts {
625 if !seen.insert(member.destination().to_path_buf()) {
626 return Err(AdapterError::MapMismatch("destinations"));
627 }
628 }
629 let set = ArtifactSet::new(artifacts).map_err(|e| AdapterError::Eggup(e.to_string()))?;
630 InstallPlan::new(product.clone(), release.clone(), destination_root, set)
631 .map_err(|e| AdapterError::Eggup(e.to_string()))
632}
633
634pub fn core_plan_for_archive(
651 projection: &ManifestProjection,
652 extraction_root: &Path,
653 destination_root: &Path,
654 permissions: HashMap<MemberId, PermissionsIntent>,
655) -> Result<InstallPlan, AdapterError> {
656 let destinations = projection.default_destinations()?;
657 core_plan_for_archive_with_destinations(
658 projection,
659 extraction_root,
660 destination_root,
661 destinations,
662 permissions,
663 )
664}
665
666pub fn bind_archive_members(
682 projection: &ManifestProjection,
683 bound_members: Vec<BoundMember>,
684) -> Result<BoundSources, AdapterError> {
685 let members = match projection {
686 ManifestProjection::Archive { members, .. } => members,
687 _ => return Err(AdapterError::ArchiveExtractionRequired),
688 };
689 if members.len() != bound_members.len() {
690 return Err(AdapterError::MapMismatch("archive bound members"));
691 }
692 let mut sources = BoundSources::new();
693 for (declared, bound) in members.iter().zip(bound_members) {
694 if bound.source_path() != declared.source || bound.output_name() != declared.install {
699 return Err(AdapterError::MapMismatch("archive bound member identity"));
700 }
701 let id = MemberId::new(declared.install.clone())
702 .map_err(|e| AdapterError::Eggup(e.to_string()))?;
703 sources.insert(id, bound.into_open_object());
707 }
708 Ok(sources)
709}
710
711#[cfg(test)]
712mod tests {
713 use super::*;
714
715 fn direct_json() -> Vec<u8> {
716 include_bytes!("../tests/fixtures/direct-manifest.json").to_vec()
717 }
718
719 #[test]
720 fn bounded_json_projection_accepts_fixture_and_exact_limit() {
721 let fixture = direct_json();
722 assert!(fixture.len() < MAX_MANIFEST_BYTES);
723 assert!(matches!(
724 project_json(&fixture, "x86_64-unknown-linux-gnu").unwrap(),
725 ManifestProjection::Installable { .. }
726 ));
727
728 let mut at_limit = fixture;
729 at_limit.resize(MAX_MANIFEST_BYTES, b' ');
730 assert!(project_json(&at_limit, "x86_64-unknown-linux-gnu").is_ok());
731 }
732
733 #[test]
734 fn bounded_json_projection_rejects_invalid_documents_without_leaking_input() {
735 let oversized = vec![b' '; MAX_MANIFEST_BYTES + 1];
736 let invalid_utf8 = [b'{', 0xff, b'}'];
737 let malformed = br#"{"private":"https://user:super-secret@example.invalid/?token=hidden""#;
738 let unsupported: Vec<u8> = String::from_utf8(direct_json())
739 .unwrap()
740 .replace("\"schema_version\":1", "\"schema_version\":999")
741 .into_bytes();
742
743 for input in [
744 &oversized[..],
745 &invalid_utf8[..],
746 &malformed[..],
747 &unsupported[..],
748 ] {
749 let error = project_json(input, "x86_64-unknown-linux-gnu").unwrap_err();
750 assert!(matches!(error, AdapterError::InvalidManifest));
751 let diagnostic = format!("{error} {error:?}");
752 assert!(!diagnostic.contains("private"));
753 assert!(!diagnostic.contains("super-secret"));
754 assert!(!diagnostic.contains("token=hidden"));
755 }
756 }
757
758 #[test]
759 fn json_projection_keeps_exact_target_selection() {
760 let error = project_json(&direct_json(), "linux-x64").unwrap_err();
761 assert!(matches!(error, AdapterError::TargetNotFound));
762 }
763
764 #[test]
765 fn corrected_fixtures_project_and_archive_stays_separate() {
766 let direct: ReleaseManifest =
767 serde_json::from_str(include_str!("../tests/fixtures/direct-manifest.json")).unwrap();
768 assert!(matches!(
769 project(&direct, "x86_64-unknown-linux-gnu").unwrap(),
770 ManifestProjection::Installable { .. }
771 ));
772 let archive: ReleaseManifest =
773 serde_json::from_str(include_str!("../tests/fixtures/archive-manifest.json")).unwrap();
774 let p = project(&archive, "x86_64-unknown-linux-gnu").unwrap();
775 assert!(matches!(p, ManifestProjection::Archive { .. }));
776 assert!(matches!(
777 p.bind_requests(HashMap::new(), FetchLimits::default()),
778 Err(AdapterError::MapMismatch(_))
779 ));
780 let b: ReleaseManifest =
781 serde_json::from_str(include_str!("../tests/fixtures/bundle-manifest.json")).unwrap();
782 assert!(
783 matches!(project(&b, "x86_64-unknown-linux-gnu").unwrap(), ManifestProjection::Installable { artifacts, .. } if artifacts.len() == 3)
784 );
785 }
786 #[test]
787 fn alias_target_is_not_resolved() {
788 let m: ReleaseManifest =
789 serde_json::from_str(include_str!("../tests/fixtures/direct-manifest.json")).unwrap();
790 assert!(matches!(
791 project(&m, "linux-x64"),
792 Err(AdapterError::TargetNotFound)
793 ));
794 }
795
796 #[test]
797 fn exact_request_binding_preserves_url_and_tightens_byte_limit() {
798 let m: ReleaseManifest =
799 serde_json::from_str(include_str!("../tests/fixtures/direct-manifest.json")).unwrap();
800 let p = project(&m, "x86_64-unknown-linux-gnu").unwrap();
801 let name = match &p {
802 ManifestProjection::Installable { artifacts, .. } => artifacts[0].artifact_name.clone(),
803 _ => unreachable!(),
804 };
805 let request =
806 AcquisitionRequest::new("https://user:secret@example.test/path?token=kept").unwrap();
807 let mut requests = HashMap::new();
808 requests.insert(name.clone(), request.clone());
809 let bound = p.bind_requests(requests, FetchLimits::default()).unwrap();
810 assert_eq!(bound[0].request, request);
811 assert_eq!(bound[0].limits.max_artifact_bytes, bound[0].exact_size);
812 let too_small = FetchLimits {
813 max_artifact_bytes: bound[0].exact_size - 1,
814 ..FetchLimits::default()
815 };
816 assert!(matches!(
817 p.bind_requests(HashMap::from([(name, request)]), too_small),
818 Err(AdapterError::CallerLimitTooSmall(_))
819 ));
820 }
821
822 #[test]
823 fn exact_size_and_explicit_permissions_gate_artifact_materialization() {
824 let m: ReleaseManifest =
825 serde_json::from_str(include_str!("../tests/fixtures/direct-manifest.json")).unwrap();
826 let p = project(&m, "x86_64-unknown-linux-gnu").unwrap();
827 let requirement = match &p {
828 ManifestProjection::Installable { artifacts, .. } => &artifacts[0],
829 _ => unreachable!(),
830 };
831 let dir = std::env::temp_dir().join(format!("eggup-eggpack-test-{}", std::process::id()));
832 let _ = fs::remove_dir_all(&dir);
833 fs::create_dir_all(&dir).unwrap();
834 let path = dir.join("source");
835 fs::write(&path, b"abc").unwrap();
836 let acquired = HashMap::from([(requirement.artifact_name.clone(), path.clone())]);
837 let permissions =
838 HashMap::from([(requirement.member_id.clone(), PermissionsIntent::Executable)]);
839 assert!(p
840 .materialize_artifact_set(acquired.clone(), permissions.clone())
841 .is_ok());
842 fs::write(&path, b"no").unwrap();
843 assert!(matches!(
844 p.materialize_artifact_set(acquired, permissions),
845 Err(AdapterError::InvalidAcquiredFile(_))
846 ));
847 let _ = fs::remove_dir_all(dir);
848 }
849}