ci: test for coverage

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

Author: imeoer

api/src/config.rs

@@ -2558,6 +2558,261 @@ mod tests {
         assert_eq!(default_prefetch_threads_count(), 8);
     }
 
+    #[test]
+    fn test_clone_without_secrets() {
+        let content = r#"version=2
+        [backend]
+        type = "oss"
+        [backend.oss]
+        endpoint = "my_endpoint"
+        bucket_name = "my_bucket"
+        access_key_id = "my_ak_id"
+        access_key_secret = "my_ak_secret"
+        [backend.registry]
+        host = "localhost"
+        repo = "nydus"
+        auth = "my_auth_token"
+        registry_token = "my_bearer_token"
+        "#;
+        let cfg: ConfigV2 = toml::from_str(content).unwrap();
+        let clean = cfg.clone_without_secrets();
+
+        // Secrets must be erased.
+        let backend = clean.backend.as_ref().unwrap();
+        let oss = backend.oss.as_ref().unwrap();
+        assert!(oss.access_key_id.is_empty());
+        assert!(oss.access_key_secret.is_empty());
+        // Non-secret field must be preserved.
+        assert_eq!(&oss.endpoint, "my_endpoint");
+
+        let registry = backend.registry.as_ref().unwrap();
+        assert!(registry.auth.is_none());
+        assert!(registry.registry_token.is_none());
+        // Non-secret field must be preserved.
+        assert_eq!(&registry.host, "localhost");
+
+        // Original must be untouched.
+        let orig_backend = cfg.backend.as_ref().unwrap();
+        assert_eq!(
+            &orig_backend.oss.as_ref().unwrap().access_key_id,
+            "my_ak_id"
+        );
+    }
+
+    #[test]
+    fn test_clone_without_secrets_no_backend() {
+        let cfg = ConfigV2::new("id1");
+        // Should not panic even when backend is None.
+        let clean = cfg.clone_without_secrets();
+        assert!(clean.backend.is_none());
+    }
+
+    #[test]
+    fn test_is_chunk_validation_enabled() {
+        // Both absent → false.
+        let cfg = ConfigV2::new("id1");
+        assert!(!cfg.is_chunk_validation_enabled());
+
+        // Only cache.validate = true → true.
+        let content = r#"version=2
+        [cache]
+        type = "filecache"
+        validate = true
+        "#;
+        let cfg: ConfigV2 = toml::from_str(content).unwrap();
+        assert!(cfg.is_chunk_validation_enabled());
+
+        // Only rafs.validate = true → true.
+        let content = r#"version=2
+        [rafs]
+        validate = true
+        "#;
+        let cfg: ConfigV2 = toml::from_str(content).unwrap();
+        assert!(cfg.is_chunk_validation_enabled());
+
+        // Both false → false.
+        let content = r#"version=2
+        [cache]
+        type = "filecache"
+        validate = false
+        [rafs]
+        validate = false
+        "#;
+        let cfg: ConfigV2 = toml::from_str(content).unwrap();
+        assert!(!cfg.is_chunk_validation_enabled());
+    }
+
+    #[test]
+    fn test_is_fs_cache() {
+        // No cache → false.
+        let cfg = ConfigV2::new("id1");
+        assert!(!cfg.is_fs_cache());
+
+        // Cache with fscache sub-config → true.
+        let content = r#"version=2
+        [cache]
+        type = "fscache"
+        [cache.fscache]
+        work_dir = "/tmp"
+        "#;
+        let cfg: ConfigV2 = toml::from_str(content).unwrap();
+        assert!(cfg.is_fs_cache());
+
+        // Cache with only filecache sub-config → false.
+        let content = r#"version=2
+        [cache]
+        type = "filecache"
+        [cache.filecache]
+        work_dir = "/tmp"
+        "#;
+        let cfg: ConfigV2 = toml::from_str(content).unwrap();
+        assert!(!cfg.is_fs_cache());
+    }
+
+    #[test]
+    fn test_get_cache_working_directory_missing_sub_config() {
+        // filecache type but no [cache.filecache] section → error.
+        let content = r#"version=2
+        [cache]
+        type = "filecache"
+        "#;
+        let cfg: ConfigV2 = toml::from_str(content).unwrap();
+        assert!(cfg.get_cache_working_directory().is_err());
+
+        // fscache type but no [cache.fscache] section → error.
+        let content = r#"version=2
+        [cache]
+        type = "fscache"
+        "#;
+        let cfg: ConfigV2 = toml::from_str(content).unwrap();
+        assert!(cfg.get_cache_working_directory().is_err());
+    }
+
+    #[test]
+    fn test_backend_get_config_success_and_type_mismatch() {
+        // localdisk: success path and "wrong accessor" path.
+        let cfg = BackendConfigV2 {
+            backend_type: "localdisk".to_string(),
+            localdisk: Some(LocalDiskConfig {
+                device_path: "/dev/sda".to_string(),
+                disable_gpt: false,
+            }),
+            ..Default::default()
+        };
+        assert!(cfg.get_localdisk_config().is_ok());
+        // Wrong accessor on localdisk config → wrong-type error.
+        assert!(cfg.get_localfs_config().is_err());
+
+        // localfs: success path.
+        let cfg = BackendConfigV2 {
+            backend_type: "localfs".to_string(),
+            localfs: Some(LocalFsConfig {
+                dir: "/tmp".to_string(),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        assert!(cfg.get_localfs_config().is_ok());
+        assert!(cfg.get_oss_config().is_err());
+
+        // oss: success path.
+        let cfg = BackendConfigV2 {
+            backend_type: "oss".to_string(),
+            oss: Some(OssConfig {
+                endpoint: "ep".to_string(),
+                bucket_name: "bkt".to_string(),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        assert!(cfg.get_oss_config().is_ok());
+        assert!(cfg.get_s3_config().is_err());
+
+        // s3: success path.
+        let cfg = BackendConfigV2 {
+            backend_type: "s3".to_string(),
+            s3: Some(S3Config {
+                region: "us-east-1".to_string(),
+                bucket_name: "bkt".to_string(),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        assert!(cfg.get_s3_config().is_ok());
+        assert!(cfg.get_registry_config().is_err());
+
+        // registry: success path.
+        let cfg = BackendConfigV2 {
+            backend_type: "registry".to_string(),
+            registry: Some(RegistryConfig {
+                host: "localhost".to_string(),
+                repo: "nydus".to_string(),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        assert!(cfg.get_registry_config().is_ok());
+        assert!(cfg.get_http_proxy_config().is_err());
+
+        // http-proxy: success path.
+        let cfg = BackendConfigV2 {
+            backend_type: "http-proxy".to_string(),
+            http_proxy: Some(HttpProxyConfig {
+                addr: "http://localhost:8080".to_string(),
+                ..Default::default()
+            }),
+            ..Default::default()
+        };
+        assert!(cfg.get_http_proxy_config().is_ok());
+        assert!(cfg.get_localdisk_config().is_err());
+    }
+
+    #[test]
+    fn test_backend_get_config_correct_type_missing_sub_config() {
+        // Correct type, but sub-config struct is None → InvalidData error.
+        let cfg = BackendConfigV2 {
+            backend_type: "localdisk".to_string(),
+            ..Default::default()
+        };
+        let err = cfg.get_localdisk_config().unwrap_err();
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
+
+        let cfg = BackendConfigV2 {
+            backend_type: "localfs".to_string(),
+            ..Default::default()
+        };
+        let err = cfg.get_localfs_config().unwrap_err();
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
+
+        let cfg = BackendConfigV2 {
+            backend_type: "oss".to_string(),
+            ..Default::default()
+        };
+        let err = cfg.get_oss_config().unwrap_err();
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
+
+        let cfg = BackendConfigV2 {
+            backend_type: "s3".to_string(),
+            ..Default::default()
+        };
+        let err = cfg.get_s3_config().unwrap_err();
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
+
+        let cfg = BackendConfigV2 {
+            backend_type: "registry".to_string(),
+            ..Default::default()
+        };
+        let err = cfg.get_registry_config().unwrap_err();
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
+
+        let cfg = BackendConfigV2 {
+            backend_type: "http-proxy".to_string(),
+            ..Default::default()
+        };
+        let err = cfg.get_http_proxy_config().unwrap_err();
+        assert_eq!(err.kind(), std::io::ErrorKind::InvalidData);
+    }
+
     #[test]
     fn test_backend_config_try_from() {
         let config = BackendConfig {

api/src/http_handler.rs

@@ -405,4 +405,75 @@ mod tests {
         assert!(msg.is_none());
         let _ = thread.join().unwrap();
     }
+
+    #[test]
+    fn test_translate_status_code() {
+        use crate::{ApiError, DaemonErrorKind, MetricsError, MetricsErrorKind};
+
+        assert_eq!(
+            translate_status_code(&ApiError::DaemonAbnormal(DaemonErrorKind::NotReady)),
+            StatusCode::ServiceUnavailable
+        );
+        assert_eq!(
+            translate_status_code(&ApiError::DaemonAbnormal(DaemonErrorKind::Unsupported)),
+            StatusCode::NotImplemented
+        );
+        assert_eq!(
+            translate_status_code(&ApiError::DaemonAbnormal(DaemonErrorKind::UnexpectedEvent(
+                "ev".into()
+            ))),
+            StatusCode::BadRequest
+        );
+        // Other DaemonErrorKind → InternalServerError
+        assert_eq!(
+            translate_status_code(&ApiError::DaemonAbnormal(DaemonErrorKind::Other(
+                "x".into()
+            ))),
+            StatusCode::InternalServerError
+        );
+        // Metrics NoCounter → NotFound
+        assert_eq!(
+            translate_status_code(&ApiError::Metrics(MetricsErrorKind::Stats(
+                MetricsError::NoCounter
+            ))),
+            StatusCode::NotFound
+        );
+        // Catch-all → InternalServerError
+        assert_eq!(
+            translate_status_code(&ApiError::ResponsePayloadType),
+            StatusCode::InternalServerError
+        );
+        // MountFilesystem variant
+        assert_eq!(
+            translate_status_code(&ApiError::MountFilesystem(DaemonErrorKind::Unsupported)),
+            StatusCode::NotImplemented
+        );
+    }
+
+    #[test]
+    fn test_success_response() {
+        let resp_with_body = success_response(Some("hello".into()));
+        assert_eq!(resp_with_body.status(), StatusCode::OK);
+
+        let resp_no_body = success_response(None);
+        assert_eq!(resp_no_body.status(), StatusCode::NoContent);
+    }
+
+    #[test]
+    fn test_error_response() {
+        let resp = error_response(HttpError::NoRoute, StatusCode::NotFound);
+        assert_eq!(resp.status(), StatusCode::NotFound);
+    }
+
+    #[test]
+    fn test_parse_body() {
+        let body = Body::new(r#"{"key":"value"}"#.to_string());
+        let result: std::result::Result<serde_json::Value, HttpError> = parse_body(&body);
+        assert!(result.is_ok());
+
+        let bad_body = Body::new("not json".to_string());
+        let result: std::result::Result<serde_json::Value, HttpError> = parse_body(&bad_body);
+        assert!(result.is_err());
+        assert!(matches!(result.unwrap_err(), HttpError::ParseBody(_)));
+    }
 }