ci(ut): add ut for test coverage

Signed-off-by: imeoer <yansong.ys@antgroup.com>

Author: imeoer

.github/workflows/smoke.yml

@@ -301,6 +301,96 @@ jobs:
           path: |
             codecov.json
 
+  nydus-integration-test-coverage:
+    if: github.event_name == 'pull_request'
+    needs: [contrib-build]
+    runs-on: ubuntu-latest
+    env:
+      CARGO_TERM_COLOR: always
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v6
+    - name: Rust Cache
+      uses: Swatinem/rust-cache@v2
+      with:
+        cache-on-failure: true
+        shared-key: Linux-cargo-amd64-coverage
+        save-if: ${{ github.ref == 'refs/heads/master' }}
+    - name: Install cargo-llvm-cov
+      uses: taiki-e/install-action@cargo-llvm-cov
+    - name: Setup Golang
+      uses: actions/setup-go@v5
+      with:
+        go-version-file: 'go.work'
+        cache-dependency-path: "**/*.sum"
+    - name: Download Nydusify
+      uses: actions/download-artifact@v7
+      with:
+        name: nydusify-artifact
+        path: contrib/nydusify/cmd
+    - name: Fscache Setup
+      run: sudo bash misc/fscache/setup.sh
+    - name: Prepare Older Binaries
+      run: |
+        export NYDUS_STABLE_VERSION=$(curl https://api.github.com/repos/Dragonflyoss/nydus/releases/latest | jq -r '.tag_name')
+
+        versions=(v0.1.0 ${NYDUS_STABLE_VERSION})
+        version_archs=(v0.1.0-x86_64 ${NYDUS_STABLE_VERSION}-linux-amd64)
+        for i in ${!versions[@]}; do
+          version=${versions[$i]}
+          version_arch=${version_archs[$i]}
+
+          wget -q https://github.com/dragonflyoss/nydus/releases/download/$version/nydus-static-$version_arch.tgz
+          sudo mkdir -p nydus-$version /usr/bin/nydus-$version
+          sudo tar xzf nydus-static-$version_arch.tgz -C nydus-$version
+          sudo cp -r nydus-$version/nydus-static/* /usr/bin/nydus-$version/
+        done
+    - name: Free Disk Space
+      uses: jlumbroso/free-disk-space@main
+      with:
+        tool-cache: false
+        android: true
+        dotnet: true
+        haskell: true
+        large-packages: true
+        docker-images: true
+        swap-storage: true
+    - name: Generate integration coverage
+      shell: bash
+      run: |
+        source <(cargo llvm-cov show-env --sh)
+        cargo llvm-cov clean --workspace
+        cargo build --release --features=virtiofs --bins
+
+        sudo mkdir -p /usr/bin/nydus-latest /home/runner/work/workdir
+        sudo install -D -m 755 contrib/nydusify/cmd/nydusify /usr/bin/nydus-latest
+        sudo install -D -m 755 target/release/nydusd target/release/nydus-image /usr/bin/nydus-latest
+        sudo bash misc/prepare.sh
+
+        export NYDUS_STABLE_VERSION=$(curl https://api.github.com/repos/Dragonflyoss/nydus/releases/latest | jq -r '.tag_name')
+        export NYDUS_STABLE_VERSION_EXPORT="${NYDUS_STABLE_VERSION//./_}"
+
+        versions=(v0.1.0 ${NYDUS_STABLE_VERSION} latest)
+        version_exports=(v0_1_0 ${NYDUS_STABLE_VERSION_EXPORT} latest)
+        for i in ${!version_exports[@]}; do
+          version=${versions[$i]}
+          version_export=${version_exports[$i]}
+          export NYDUS_BUILDER_$version_export=/usr/bin/nydus-$version/nydus-image
+          export NYDUS_NYDUSD_$version_export=/usr/bin/nydus-$version/nydusd
+          export NYDUS_NYDUSIFY_$version_export=/usr/bin/nydus-$version/nydusify
+        done
+
+        curl -sSfL https://raw.githubusercontent.com/golangci/golangci-lint/master/install.sh | sudo sh -s -- -b /usr/bin v2.1.6
+        sudo -E make smoke-only
+
+        cargo llvm-cov report --release --codecov --output-path smoke-codecov.json
+    - name: Upload integration coverage file
+      uses: actions/upload-artifact@v6
+      with:
+        name: nydus-integration-test-coverage-artifact
+        path: |
+          smoke-codecov.json
+
   upload-coverage-to-codecov:
     runs-on: ubuntu-latest
     needs: [contrib-unit-test-coverage, nydus-unit-test-coverage]
@@ -323,6 +413,25 @@ jobs:
         verbose: true
         fail_ci_if_error: true
 
+  upload-integration-coverage-to-codecov:
+    if: github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    needs: [nydus-integration-test-coverage]
+    steps:
+    - uses: actions/checkout@v6
+    - name: Download nydus integration coverage file
+      uses: actions/download-artifact@v7
+      with:
+        name: nydus-integration-test-coverage-artifact
+    - name: Upload integration coverage to Codecov
+      uses: codecov/codecov-action@v5
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      with:
+        files: ./smoke-codecov.json
+        verbose: true
+        fail_ci_if_error: true
+
   nydus-cargo-deny:
     name: cargo-deny
     runs-on: ubuntu-latest

api/src/config.rs

@@ -2176,7 +2176,7 @@ mod tests {
             }
           }"#;
 
-        let mut rafs_config = ConfigV2::from_str(&config).unwrap();
+        let mut rafs_config = ConfigV2::from_str(config).unwrap();
         let test_auth = "test_auth".to_string();
 
         rafs_config.update_registry_auth_info(&Some(test_auth.clone()));

builder/src/core/blob.rs

@@ -106,12 +106,8 @@ impl Blob {
             if let Some((_, blob_ctx)) = blob_mgr.get_current_blob() {
                 let mut batch = batch.lock().unwrap();
                 if !batch.chunk_data_buf_is_empty() {
-                    let (_, compressed_size, _) = Node::write_chunk_data(
-                        &ctx,
-                        blob_ctx,
-                        blob_writer,
-                        batch.chunk_data_buf(),
-                    )?;
+                    let (_, compressed_size, _) =
+                        Node::write_chunk_data(ctx, blob_ctx, blob_writer, batch.chunk_data_buf())?;
                     batch.add_context(compressed_size);
                     batch.clear_chunk_data_buf();
                 }
@@ -226,7 +222,7 @@ impl Blob {
         header.set_ci_entries(blob_meta_info.len() as u32);
         header.set_ci_compressed_offset(compressed_offset);
         header.set_ci_compressed_size(compressed_size as u64);
-        header.set_ci_uncompressed_size(uncompressed_size as u64);
+        header.set_ci_uncompressed_size(uncompressed_size);
         header.set_aligned(true);
         match blob_meta_info {
             BlobMetaChunkArray::V1(_) => header.set_chunk_info_v2(false),
@@ -280,7 +276,7 @@ impl Blob {
                 hasher.digest_finalize(),
                 compressed_offset,
                 compressed_size as u64,
-                uncompressed_size as u64,
+                uncompressed_size,
             )?;
 
             let mut hasher = RafsDigest::hasher(digest::Algorithm::Sha256);

builder/src/core/context.rs

@@ -452,7 +452,7 @@ impl BlobCacheGenerator {
 
         guard.seek(std::io::SeekFrom::Start(chunk_info.uncompressed_offset()))?;
         guard
-            .write_all(&chunk_data)
+            .write_all(chunk_data)
             .context("failed to write blob cache")?;
         Ok(())
     }
@@ -1002,7 +1002,7 @@ impl BlobManager {
                 self.add_blob(blob_ctx);
             }
         }
-        Ok((blob_idx as u32, &mut self.blobs[blob_idx as usize]))
+        Ok((blob_idx as u32, &mut self.blobs[blob_idx]))
     }
 
     /// Get the current blob object.

builder/src/core/node.rs

@@ -302,11 +302,9 @@ impl Node {
             external_blob_ctx.blob_id = external_blob_id.to_string();
             external_blob_ctx.compressed_blob_size = external_compressed_size;
             external_blob_ctx.uncompressed_blob_size = external_compressed_size;
-            let chunk_count = self
-                .chunk_count(external_chunk_size as u64)
-                .with_context(|| {
-                    format!("failed to get chunk count for {}", self.path().display())
-                })?;
+            let chunk_count = self.chunk_count(external_chunk_size).with_context(|| {
+                format!("failed to get chunk count for {}", self.path().display())
+            })?;
             self.inode.set_child_count(chunk_count);
 
             info!(
@@ -320,7 +318,7 @@ impl Node {
             );
             for i in 0..self.inode.child_count() {
                 let mut chunk = self.inode.create_chunk();
-                let file_offset = i as u64 * external_chunk_size as u64;
+                let file_offset = i as u64 * external_chunk_size;
                 let compressed_size = if i == self.inode.child_count() - 1 {
                     self.inode.size() - (external_chunk_size * i as u64)
                 } else {

builder/src/core/overlay.rs

@@ -229,9 +229,14 @@ mod tests {
         assert!(matches!(spec, WhiteoutSpec::Oci));
 
         assert!(WhiteoutSpec::from_str("oci").is_ok());
+        assert!(WhiteoutSpec::from_str("OCI").is_ok());
         assert!(WhiteoutSpec::from_str("overlayfs").is_ok());
         assert!(WhiteoutSpec::from_str("none").is_ok());
         assert!(WhiteoutSpec::from_str("foo").is_err());
+
+        assert_eq!(WhiteoutSpec::Oci.to_string(), "oci");
+        assert_eq!(WhiteoutSpec::Overlayfs.to_string(), "overlayfs");
+        assert_eq!(WhiteoutSpec::None.to_string(), "none");
     }
 
     #[test]
@@ -255,6 +260,10 @@ mod tests {
         assert!(t1.is_lower_layer());
         assert!(!t2.is_lower_layer());
         assert!(!t3.is_lower_layer());
+
+        assert_eq!(t1.to_string(), "LOWER");
+        assert_eq!(t2.to_string(), "ADDED");
+        assert_eq!(t3.to_string(), "MODIFIED");
     }
 
     #[test]

builder/src/core/v6.rs

@@ -71,7 +71,7 @@ impl Node {
         if self.is_dir() {
             self.v6_dump_dir(ctx, f_bootstrap, meta_addr, meta_offset, &mut inode)?;
         } else if self.is_reg() {
-            self.v6_dump_file(ctx, f_bootstrap, chunk_cache, &mut inode, &blobs)?;
+            self.v6_dump_file(ctx, f_bootstrap, chunk_cache, &mut inode, blobs)?;
         } else if self.is_symlink() {
             self.v6_dump_symlink(ctx, f_bootstrap, &mut inode)?;
         } else {
@@ -171,7 +171,7 @@ impl Node {
                 let len = c.len() + size_of::<RafsV6Dirent>();
                 // erofs disk format requires dirent to be aligned to block size.
                 if (d_size % block_size) + len as u64 > block_size {
-                    d_size = round_up(d_size as u64, block_size);
+                    d_size = round_up(d_size, block_size);
                 }
                 d_size += len as u64;
             }
@@ -185,7 +185,7 @@ impl Node {
                 let len = child.name().len() + size_of::<RafsV6Dirent>();
                 // erofs disk format requires dirent to be aligned to block size.
                 if (d_size % block_size) + len as u64 > block_size {
-                    d_size = round_up(d_size as u64, block_size);
+                    d_size = round_up(d_size, block_size);
                 }
                 d_size += len as u64;
             }
@@ -380,7 +380,7 @@ impl Node {
                 }
 
                 f_bootstrap
-                    .seek(SeekFrom::Start(dirent_off as u64))
+                    .seek(SeekFrom::Start(dirent_off))
                     .context("failed seek file position for writing dirent")?;
                 f_bootstrap
                     .write(dir_data.as_slice())
@@ -736,7 +736,7 @@ impl Bootstrap {
                 ext_sb.set_prefetch_table_size(prefetch_table_size);
                 bootstrap_ctx
                     .writer
-                    .seek_offset(prefetch_table_offset as u64)
+                    .seek_offset(prefetch_table_offset)
                     .context("failed seek prefetch table offset")?;
                 pt.store(bootstrap_ctx.writer.as_mut()).unwrap();
             }

builder/src/lib.rs

@@ -379,18 +379,18 @@ mod tests {
         let builder = TarBuilder::new(true, 0, RafsVersion::V6);
 
         let path = Path::new("/stargz.index.json");
-        assert!(builder.is_stargz_special_files(&path));
+        assert!(builder.is_stargz_special_files(path));
         let path = Path::new("/.prefetch.landmark");
-        assert!(builder.is_stargz_special_files(&path));
+        assert!(builder.is_stargz_special_files(path));
         let path = Path::new("/.no.prefetch.landmark");
-        assert!(builder.is_stargz_special_files(&path));
+        assert!(builder.is_stargz_special_files(path));
 
         let path = Path::new("/no.prefetch.landmark");
-        assert!(!builder.is_stargz_special_files(&path));
+        assert!(!builder.is_stargz_special_files(path));
         let path = Path::new("/prefetch.landmark");
-        assert!(!builder.is_stargz_special_files(&path));
+        assert!(!builder.is_stargz_special_files(path));
         let path = Path::new("/tar.index.json");
-        assert!(!builder.is_stargz_special_files(&path));
+        assert!(!builder.is_stargz_special_files(path));
     }
 
     #[test]

builder/src/merge.rs

@@ -140,7 +140,7 @@ impl Merger {
                     .context(format!("load parent bootstrap {:?}", parent_bootstrap_path))?;
             let blobs = rs.superblock.get_blob_infos();
             for blob in &blobs {
-                let blob_ctx = BlobContext::from(ctx, &blob, ChunkSource::Parent)?;
+                let blob_ctx = BlobContext::from(ctx, blob, ChunkSource::Parent)?;
                 blob_idx_map.insert(blob_ctx.blob_id.clone(), blob_mgr.len());
                 blob_mgr.add_blob(blob_ctx);
             }
@@ -188,7 +188,7 @@ impl Merger {
             let mut parent_blob_added = false;
             let blobs = &rs.superblock.get_blob_infos();
             for blob in blobs {
-                let mut blob_ctx = BlobContext::from(ctx, &blob, ChunkSource::Parent)?;
+                let mut blob_ctx = BlobContext::from(ctx, blob, ChunkSource::Parent)?;
                 if let Some(chunk_size) = chunk_size {
                     ensure!(
                         chunk_size == blob_ctx.chunk_size,

builder/src/optimize_prefetch.rs

@@ -108,7 +108,7 @@ impl OptimizePrefetch {
             RafsBlobTable::V6(table) => table.get_all().len(),
         };
         let mut blob_state =
-            PrefetchBlobState::new(&ctx, blob_layer_num as u32, &output_blob_dir_path)?;
+            PrefetchBlobState::new(ctx, blob_layer_num as u32, &output_blob_dir_path)?;
         let mut batch = BatchContextGenerator::new(0)?;
         for node in prefetch_files.clone() {
             Self::process_prefetch_node(
@@ -146,7 +146,7 @@ impl OptimizePrefetch {
         // carefully address hardlink
         for node in prefetch_files.clone() {
             let file = &node.path;
-            if tree.get_node(&file).is_none() {
+            if tree.get_node(file).is_none() {
                 warn!(
                     "prefetch file {} is skipped, no need to fixing hardlink",
                     file.display()
@@ -155,7 +155,7 @@ impl OptimizePrefetch {
             }
 
             let tree_node = tree
-                .get_node(&file)
+                .get_node(file)
                 .ok_or(anyhow!("failed to get node"))?
                 .node
                 .as_ref();
@@ -182,7 +182,7 @@ impl OptimizePrefetch {
             RafsBlobTable::V6(table) => table.get_all(),
         };
         blob_mgr.extend_from_blob_table(ctx, blob_info)?;
-        let blob_table_withprefetch = blob_mgr.to_blob_table(&ctx)?;
+        let blob_table_withprefetch = blob_mgr.to_blob_table(ctx)?;
 
         bootstrap.dump(
             ctx,
@@ -210,10 +210,10 @@ impl OptimizePrefetch {
         let mut blob_mgr = BlobManager::new(ctx.digester, false);
         blob_mgr.add_blob(blob_state.blob_ctx.clone());
         blob_mgr.set_current_blob_index(0);
-        Blob::finalize_blob_data(&ctx, &mut blob_mgr, blob_state.blob_writer.as_mut())?;
+        Blob::finalize_blob_data(ctx, &mut blob_mgr, blob_state.blob_writer.as_mut())?;
         if let RafsBlobTable::V6(_) = blob_table {
             if let Some((_, blob_ctx)) = blob_mgr.get_current_blob() {
-                Blob::dump_meta_data(&ctx, blob_ctx, blob_state.blob_writer.as_mut()).unwrap();
+                Blob::dump_meta_data(ctx, blob_ctx, blob_state.blob_writer.as_mut()).unwrap();
             };
         }
         ctx.blob_id = String::from("");
@@ -340,7 +340,7 @@ impl OptimizePrefetch {
                     (blob_info.meta_ci_uncompressed_size()
                         + size_of::<BlobChunkInfoV2Ondisk>() as u64) as usize,
                 );
-                blob_ctx.add_chunk_meta_info(&inner, Some(info))?;
+                blob_ctx.add_chunk_meta_info(inner, Some(info))?;
             }
             blob_ctx.compressed_blob_size += inner.compressed_size() as u64;
             blob_ctx.uncompressed_blob_size += aligned_d_size;