ptfs: add unit tests for mount fd

Add unit tests for mount fd.

Signed-off-by: Jiang Liu <[email protected]>

Author: jiangliu

src/passthrough/file_handle.rs

@@ -1,3 +1,4 @@
+// Copyright (C) 2023 Alibaba Cloud. All rights reserved.
 // Copyright 2021 Red Hat, Inc. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
@@ -281,10 +282,7 @@ impl OpenableFileHandle {
         })
     }
 
-    /// Open a file handle (low-level wrapper).
-    ///
-    /// `mount_fd` must be an open non-`O_PATH` file descriptor for an inode on the same mount as
-    /// the file to be opened, i.e. the mount given by `self.mnt_id`.
+    /// Open a file from an openable file handle.
     pub fn open(&self, flags: libc::c_int) -> io::Result<File> {
         let ret = unsafe {
             open_by_handle_at(
@@ -316,6 +314,8 @@ impl OpenableFileHandle {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::ffi::CString;
+    use std::io::Read;
 
     fn generate_c_file_handle(
         handle_bytes: usize,
@@ -367,12 +367,12 @@ mod tests {
         };
 
         assert!(fh1 > fh2);
-        assert!(fh1 != fh2);
+        assert_ne!(fh1, fh2);
         assert!(fh1 < fh3);
-        assert!(fh1 != fh3);
+        assert_ne!(fh1, fh3);
         assert!(fh1 < fh4);
-        assert!(fh1 != fh4);
-        assert!(fh1 == fh5);
+        assert_ne!(fh1, fh4);
+        assert_eq!(fh1, fh5);
 
         unsafe {
             fh1.handle
@@ -389,7 +389,7 @@ mod tests {
                 .f_handle
                 .as_mut_slice(128)[0] = 1;
         }
-        assert!(fh1 == fh5);
+        assert_eq!(fh1, fh5);
     }
 
     #[test]
@@ -405,4 +405,47 @@ mod tests {
             buf.as_slice(),
         );
     }
+
+    #[test]
+    fn test_file_handle_from_name_at() {
+        let topdir = env!("CARGO_MANIFEST_DIR");
+        let dir = File::open(topdir).unwrap();
+        let filename = CString::new("build.rs").unwrap();
+
+        let dir_handle =
+            FileHandle::from_name_at(dir.as_raw_fd(), &CString::new("").unwrap()).unwrap();
+        let file_handle = FileHandle::from_name_at(dir.as_raw_fd(), &filename).unwrap();
+
+        assert_eq!(dir_handle.mnt_id, file_handle.mnt_id);
+        assert_ne!(
+            dir_handle.handle.wrapper.as_fam_struct_ref().handle_bytes,
+            0
+        );
+        assert_ne!(
+            file_handle.handle.wrapper.as_fam_struct_ref().handle_bytes,
+            0
+        );
+    }
+
+    #[test]
+    fn test_openable_file_handle() {
+        let topdir = env!("CARGO_MANIFEST_DIR");
+        let dir = File::open(topdir).unwrap();
+        let filename = CString::new("build.rs").unwrap();
+        let mount_fds = MountFds::new(None).unwrap();
+
+        let file_handle = OpenableFileHandle::from_name_at(
+            dir.as_raw_fd(),
+            &filename,
+            &mount_fds,
+            |_fd, _flags, _mode| File::open(topdir),
+        )
+        .unwrap();
+        assert_eq!(file_handle.handle.mnt_id, file_handle.mount_id());
+
+        let mut file = file_handle.open(libc::O_RDONLY).unwrap();
+        let mut buffer = [0u8; 1024];
+        let res = file.read(&mut buffer).unwrap();
+        assert!(res > 0);
+    }
 }

src/passthrough/mount_fd.rs

@@ -436,3 +436,57 @@ impl std::fmt::Display for MPRError {
 }
 
 impl std::error::Error for MPRError {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::passthrough::file_handle::FileHandle;
+
+    #[test]
+    fn test_mount_fd_get() {
+        let topdir = env!("CARGO_MANIFEST_DIR");
+        let dir = File::open(topdir).unwrap();
+        let filename = CString::new("build.rs").unwrap();
+        let mount_fds = MountFds::new(None).unwrap();
+        let handle = FileHandle::from_name_at(dir.as_raw_fd(), &filename).unwrap();
+
+        // Ensure that `MountFds::get()` works for new entry.
+        let fd1 = mount_fds
+            .get(handle.mnt_id, |_fd, _flags, _mode| File::open(topdir))
+            .unwrap();
+        assert_eq!(Arc::strong_count(&fd1), 1);
+        assert_eq!(mount_fds.map.read().unwrap().len(), 1);
+
+        // Ensure that `MountFds::get()` works for existing entry.
+        let fd2 = mount_fds
+            .get(handle.mnt_id, |_fd, _flags, _mode| File::open(topdir))
+            .unwrap();
+        assert_eq!(Arc::strong_count(&fd2), 2);
+        assert_eq!(mount_fds.map.read().unwrap().len(), 1);
+
+        // Ensure fd1 and fd2 are the same object.
+        assert_eq!(fd1.file().as_raw_fd(), fd2.file().as_raw_fd());
+
+        drop(fd1);
+        assert_eq!(Arc::strong_count(&fd2), 1);
+        assert_eq!(mount_fds.map.read().unwrap().len(), 1);
+
+        // Ensure that `MountFd::drop()` works as expected.
+        drop(fd2);
+        assert_eq!(mount_fds.map.read().unwrap().len(), 0);
+    }
+
+    #[test]
+    fn test_mpr_error() {
+        let io_error = io::Error::new(io::ErrorKind::Other, "test");
+        let mpr_error = MPRError::from(io_error);
+
+        assert!(!mpr_error.silent);
+        assert!(mpr_error.fs_mount_id.is_none());
+        assert!(mpr_error.fs_mount_root.is_none());
+        let mpr_error = mpr_error.silence();
+        let msg = format!("{}", mpr_error);
+        assert!(msg.len() > 0);
+        assert!(mpr_error.silent());
+    }
+}

src/passthrough/statx.rs

@@ -193,3 +193,24 @@ pub fn statx(dir: &impl AsRawFd, path: Option<&CStr>) -> io::Result<StatExt> {
         Err(io::Error::last_os_error())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ffi::CString;
+    use std::fs::File;
+
+    #[test]
+    fn test_statx() {
+        let topdir = env!("CARGO_MANIFEST_DIR");
+        let dir = File::open(topdir).unwrap();
+        let filename = CString::new("build.rs").unwrap();
+
+        let st1 = statx(&dir, None).unwrap();
+        let st2 = statx(&dir, Some(&filename)).unwrap();
+        let mnt_id = get_mount_id(&dir, &filename).unwrap();
+
+        assert_eq!(st1.mnt_id, st2.mnt_id);
+        assert_eq!(st1.mnt_id, mnt_id);
+    }
+}