✅ Refresh owner metadata fixtures

Author: ChanTsune

cli/tests/cli/migrate.rs

@@ -1,2 +1,2 @@
 mod acl_0_19_1;
-mod fprm_to_owner_facet;
+mod fprm_0_33_0;

…tests/cli/migrate/fprm_to_owner_facet.rs cli/tests/cli/migrate/fprm_0_33_0.rscli/tests/cli/migrate/fprm_to_owner_facet.rs renamed to cli/tests/cli/migrate/fprm_0_33_0.rs cli/tests/cli/migrate/fprm_to_owner_facet.rs renamed to cli/tests/cli/migrate/fprm_0_33_0.rs

@@ -5,6 +5,7 @@ use portable_network_archive::cli;
 use std::collections::BTreeMap;
 
 const PERMISSION_MODE_BITS: u16 = 0o7777;
+const LEGACY_FIXTURE: &str = "migrate_fprm_0_33_0/0.33.0/zstd_keep_all.pna";
 
 struct Captured {
     uid: u64,
@@ -24,10 +25,10 @@ struct Captured {
 #[allow(deprecated)]
 fn migrate_converts_fprm_to_owner_facet() {
     setup();
-    TestResources::extract_in("zstd_keep_all.pna", "migrate_fprm_to_owner_facet/").unwrap();
+    TestResources::extract_in("0.33.0/zstd_keep_all.pna", "migrate_fprm_0_33_0/").unwrap();
 
     let mut pre: BTreeMap<String, Captured> = BTreeMap::new();
-    archive::for_each_entry("migrate_fprm_to_owner_facet/zstd_keep_all.pna", |entry| {
+    archive::for_each_entry(LEGACY_FIXTURE, |entry| {
         let path = entry.header().path().to_string();
         let meta = entry.metadata();
         let p = meta
@@ -54,16 +55,16 @@ fn migrate_converts_fprm_to_owner_facet() {
         "experimental",
         "migrate",
         "-f",
-        "migrate_fprm_to_owner_facet/zstd_keep_all.pna",
+        LEGACY_FIXTURE,
         "--output",
-        "migrate_fprm_to_owner_facet/migrated.pna",
+        "migrate_fprm_0_33_0/migrated.pna",
     ])
     .unwrap()
     .execute()
     .unwrap();
 
     let mut post_count = 0usize;
-    archive::for_each_entry("migrate_fprm_to_owner_facet/migrated.pna", |entry| {
+    archive::for_each_entry("migrate_fprm_0_33_0/migrated.pna", |entry| {
         post_count += 1;
         let path = entry.header().path().to_string();
         let meta = entry.metadata();

cli/tests/cli/stdio/archive_source_uid_override.rs

@@ -2,11 +2,11 @@ use crate::utils::{EmbedExt, TestResources, archive, setup};
 use assert_cmd::cargo::cargo_bin_cmd;
 use std::path::PathBuf;
 
-/// Precondition: An fPRM-only archive is used as an `@archive` transform source.
+/// Precondition: An owner-facet archive is used as an `@archive` transform source.
 /// Action: Run `experimental stdio --create` with a `--uid` ownership override.
 /// Expectation: Each transformed entry carries the overridden owner uid as an
-/// owner-facet value, and the legacy fPRM chunk is NOT also emitted (no
-/// fPRM/owner-facet coexistence).
+/// owner-facet value while preserving the other owner facets, and the legacy
+/// fPRM chunk is not emitted.
 #[test]
 #[allow(deprecated)]
 fn stdio_archive_source_uid_override_drops_fprm() {
@@ -15,17 +15,29 @@ fn stdio_archive_source_uid_override_drops_fprm() {
     let base = PathBuf::from("stdio_archive_source_uid_override");
     TestResources::extract_in("zstd_keep_all.pna", &base).unwrap();
 
-    let mut pre_count = 0usize;
+    let mut pre = Vec::new();
     archive::for_each_entry(base.join("zstd_keep_all.pna"), |entry| {
-        pre_count += 1;
+        let meta = entry.metadata();
         assert!(
-            entry.metadata().permission().is_some(),
-            "fixture entry {} should carry fPRM permission",
+            meta.permission().is_none(),
+            "fixture entry {} should not carry fPRM permission",
             entry.header().path()
         );
+        assert!(
+            meta.owner_uid().is_some() && meta.permission_mode().is_some(),
+            "fixture entry {} should carry owner facets",
+            entry.header().path()
+        );
+        pre.push((
+            entry.header().path().to_string(),
+            meta.owner_gid().map(|v| v.get()),
+            meta.owner_user_name().map(|v| v.as_str().to_owned()),
+            meta.owner_group_name().map(|v| v.as_str().to_owned()),
+            meta.permission_mode().map(|v| v.get()),
+        ));
     })
     .unwrap();
-    assert!(pre_count > 0, "source archive should contain entries");
+    assert!(!pre.is_empty(), "source archive should contain entries");
 
     let output_archive = base.join("output.pna");
     cargo_bin_cmd!("pna")
@@ -47,24 +59,35 @@ fn stdio_archive_source_uid_override_drops_fprm() {
         .assert()
         .success();
 
-    let mut post_count = 0usize;
+    let mut post = Vec::new();
     archive::for_each_entry(&output_archive, |entry| {
-        post_count += 1;
         let path = entry.header().path().to_string();
         let meta = entry.metadata();
         assert!(
             meta.permission().is_none(),
-            "fPRM must not coexist with owner-facet after override for {path}"
+            "fPRM must not be emitted after owner override for {path}"
         );
         assert_eq!(
             meta.owner_uid().map(|v| v.get()),
             Some(4242),
             "overridden uid should be emitted as owner-facet for {path}"
         );
+        post.push((
+            path,
+            meta.owner_gid().map(|v| v.get()),
+            meta.owner_user_name().map(|v| v.as_str().to_owned()),
+            meta.owner_group_name().map(|v| v.as_str().to_owned()),
+            meta.permission_mode().map(|v| v.get()),
+        ));
     })
     .unwrap();
     assert_eq!(
-        post_count, pre_count,
+        post.len(),
+        pre.len(),
         "transform should preserve all entries"
     );
+    assert_eq!(
+        post, pre,
+        "uid override should preserve non-uid owner facets"
+    );
 }

cli/tests/cli/strip.rs

@@ -19,8 +19,8 @@ fn strip_removes_unspecified_metadata() {
         let path = entry.header().path().to_string();
         let meta = entry.metadata();
         assert!(
-            meta.permission().is_some() && meta.modified().is_some(),
-            "entry {path} should have both permission and timestamp before strip"
+            meta.permission_mode().is_some() && meta.modified().is_some(),
+            "entry {path} should have both permission mode and timestamp before strip"
         );
         pre_timestamps.insert(path, meta.modified());
     })
@@ -76,31 +76,44 @@ fn strip_removes_unspecified_metadata() {
     );
 }
 
-/// Precondition: An fPRM-only archive carries ownership metadata.
+/// Precondition: An archive carries ownership metadata as owner facets.
 /// Action: Run `pna strip --keep-permission`.
-/// Expectation: Ownership is preserved as owner-facet chunks (rescued from fPRM); the legacy fPRM chunk is not emitted.
+/// Expectation: Ownership is preserved as owner-facet chunks; the legacy fPRM chunk is not emitted.
 #[test]
 #[allow(deprecated)]
-fn strip_keep_permission_rescues_fprm_to_owner_facet() {
+fn strip_keep_permission_preserves_owner_facets() {
+    struct OwnerFacets {
+        uid: Option<u64>,
+        gid: Option<u64>,
+        uname: Option<String>,
+        gname: Option<String>,
+        mode: Option<u16>,
+    }
+
     setup();
     TestResources::extract_in("zstd_keep_all.pna", "strip_keep_perm/").unwrap();
 
-    let mut pre: BTreeMap<String, (u64, u64, String, String, u16)> = BTreeMap::new();
+    let mut pre: BTreeMap<String, OwnerFacets> = BTreeMap::new();
     archive::for_each_entry("strip_keep_perm/zstd_keep_all.pna", |entry| {
         let path = entry.header().path().to_string();
-        let p = entry
-            .metadata()
-            .permission()
-            .expect("fixture entry should carry fPRM permission");
+        let meta = entry.metadata();
+        assert!(
+            meta.permission().is_none(),
+            "fixture entry should not carry fPRM permission for {path}"
+        );
+        assert!(
+            meta.permission_mode().is_some(),
+            "fixture entry should carry owner-facet permission mode for {path}"
+        );
         pre.insert(
             path,
-            (
-                p.uid(),
-                p.gid(),
-                p.uname().to_string(),
-                p.gname().to_string(),
-                p.permissions(),
-            ),
+            OwnerFacets {
+                uid: meta.owner_uid().map(|v| v.get()),
+                gid: meta.owner_gid().map(|v| v.get()),
+                uname: meta.owner_user_name().map(|v| v.as_str().to_owned()),
+                gname: meta.owner_group_name().map(|v| v.as_str().to_owned()),
+                mode: meta.permission_mode().map(|v| v.get()),
+            },
         );
     })
     .unwrap();
@@ -123,40 +136,36 @@ fn strip_keep_permission_rescues_fprm_to_owner_facet() {
         post_count += 1;
         let path = entry.header().path().to_string();
         let meta = entry.metadata();
-        let (uid, gid, uname, gname, mode) = pre
+        let expected = pre
             .get(&path)
             .unwrap_or_else(|| panic!("unexpected entry after strip: {path}"));
         assert!(
             meta.permission().is_none(),
             "fPRM must not be emitted after strip --keep-permission for {path}"
         );
-        assert_eq!(meta.owner_uid().map(|v| v.get()), Some(*uid), "uid {path}");
-        assert_eq!(meta.owner_gid().map(|v| v.get()), Some(*gid), "gid {path}");
-        let expected_uname = if uname.is_empty() {
-            None
-        } else {
-            Some(uname.as_str())
-        };
-        let expected_gname = if gname.is_empty() {
-            None
-        } else {
-            Some(gname.as_str())
-        };
+        assert_eq!(
+            meta.owner_uid().map(|v| v.get()),
+            expected.uid,
+            "uid {path}"
+        );
+        assert_eq!(
+            meta.owner_gid().map(|v| v.get()),
+            expected.gid,
+            "gid {path}"
+        );
         assert_eq!(
             meta.owner_user_name().map(|v| v.as_str()),
-            expected_uname,
+            expected.uname.as_deref(),
             "uname {path}"
         );
         assert_eq!(
             meta.owner_group_name().map(|v| v.as_str()),
-            expected_gname,
+            expected.gname.as_deref(),
             "gname {path}"
         );
-        // `PermissionMode::from` masks reserved bits outside `0o7777`
-        // (file-type bits in the legacy fPRM `st_mode`) to 0 on construction.
         assert_eq!(
             meta.permission_mode().map(|v| v.get()),
-            Some(*mode & 0o7777),
+            expected.mode,
             "mode {path}"
         );
     })