diff --git a/backend/basic/src/rbum/helper/rbum_event_helper.rs b/backend/basic/src/rbum/helper/rbum_event_helper.rs
index 51fb8406b..c69869f0b 100644
--- a/backend/basic/src/rbum/helper/rbum_event_helper.rs
+++ b/backend/basic/src/rbum/helper/rbum_event_helper.rs
@@ -81,8 +81,8 @@ pub async fn get_notify_event_with_ctx(ctx: &TardisContext) -> TardisResult<Opti
     let notify_events = notify_events
         .iter()
         .filter(|(k, _)| k.starts_with(NOTIFY_EVENT_IN_CTX_FLAG))
-        .map(|(_, v)| TardisFuns::json.str_to_obj::<NotifyEventMessage>(v).unwrap())
-        .collect::<Vec<_>>();
+        .map(|(_, v)| TardisFuns::json.str_to_obj::<NotifyEventMessage>(v))
+        .collect::<TardisResult<Vec<_>>>()?;
     if notify_events.is_empty() {
         Ok(None)
     } else {
diff --git a/backend/basic/src/rbum/serv/rbum_cert_serv.rs b/backend/basic/src/rbum/serv/rbum_cert_serv.rs
index 0860cf65e..6980f2095 100644
--- a/backend/basic/src/rbum/serv/rbum_cert_serv.rs
+++ b/backend/basic/src/rbum/serv/rbum_cert_serv.rs
@@ -658,7 +658,7 @@ impl RbumCrudOperation<rbum_cert::ActiveModel, RbumCertAddReq, RbumCertModifyReq
                             Query::select()
                                 .column(rbum_cert::Column::Id)
                                 .from(rbum_cert::Entity)
-                                .and_where(Expr::col(rbum_cert::Column::Ak).eq(modify_req.ak.as_ref().unwrap().as_str()))
+                                .and_where(Expr::col(rbum_cert::Column::Ak).eq(modify_req.ak.as_ref().expect("ignore").as_str()))
                                 .and_where(Expr::col(rbum_cert::Column::RelRbumCertConfId).eq(rbum_cert_conf.id.clone()))
                                 .and_where(Expr::col(rbum_cert::Column::OwnPaths).like(format!("{}%", ctx.own_paths).as_str()))
                                 .and_where(Expr::col(rbum_cert::Column::Id).ne(id.to_string().as_str())),
diff --git a/backend/basic/src/rbum/serv/rbum_item_serv.rs b/backend/basic/src/rbum/serv/rbum_item_serv.rs
index 3a8ccb9c8..6443323f6 100644
--- a/backend/basic/src/rbum/serv/rbum_item_serv.rs
+++ b/backend/basic/src/rbum/serv/rbum_item_serv.rs
@@ -536,7 +536,7 @@ where
             }
             if let Some(rel_item_ids) = &rbum_item_rel_filter_req.rel_item_ids {
                 if rel_item_ids.len() == 1 {
-                    sub_query.and_where(Expr::col((rbum_rel::Entity, rbum_rel::Column::ToRbumItemId)).eq(rel_item_ids.first().unwrap().to_string()));
+                    sub_query.and_where(Expr::col((rbum_rel::Entity, rbum_rel::Column::ToRbumItemId)).eq(rel_item_ids.first().expect("ignore").to_string()));
                 } else if !rel_item_ids.is_empty() {
                     sub_query.and_where(Expr::col((rbum_rel::Entity, rbum_rel::Column::ToRbumItemId)).is_in(rel_item_ids));
                 }
@@ -564,7 +564,7 @@ where
             }
             if let Some(rel_item_ids) = &rbum_item_rel_filter_req.rel_item_ids {
                 if rel_item_ids.len() == 1 {
-                    sub_query.and_where(Expr::col((rbum_rel::Entity, rbum_rel::Column::FromRbumId)).eq(rel_item_ids.first().unwrap().to_string()));
+                    sub_query.and_where(Expr::col((rbum_rel::Entity, rbum_rel::Column::FromRbumId)).eq(rel_item_ids.first().expect("ignore").to_string()));
                 } else if !rel_item_ids.is_empty() {
                     sub_query.and_where(Expr::col((rbum_rel::Entity, rbum_rel::Column::FromRbumId)).is_in(rel_item_ids));
                 }
@@ -1168,8 +1168,7 @@ impl RbumItemAttrServ {
 
             for in_main_table_attr in in_main_table_attrs {
                 let column_name = Alias::new(&in_main_table_attr.name);
-                // TODO unwrap()
-                let column_val = add_req.values.get(&in_main_table_attr.name).unwrap().clone();
+                let column_val = add_req.values.get(&in_main_table_attr.name).expect("ignore").clone();
                 update_statement.value(column_name, Value::from(column_val));
             }
             update_statement.and_where(Expr::col(ID_FIELD.clone()).eq(add_req.rel_rbum_item_id.as_str()));
@@ -1178,7 +1177,7 @@ impl RbumItemAttrServ {
 
         if !in_ext_table_attrs.is_empty() {
             for in_ext_table_attr in in_ext_table_attrs {
-                let column_val = add_req.values.get(&in_ext_table_attr.name).unwrap().clone();
+                let column_val = add_req.values.get(&in_ext_table_attr.name).expect("ignore").clone();
                 let exist_item_attr_ids = Self::find_id_rbums(
                     &RbumItemAttrFilterReq {
                         basic: Default::default(),
@@ -1203,7 +1202,7 @@ impl RbumItemAttrServ {
                     )
                     .await?;
                 } else {
-                    Self::modify_rbum(exist_item_attr_ids.get(0).unwrap(), &mut RbumItemAttrModifyReq { value: column_val }, funs, ctx).await?;
+                    Self::modify_rbum(exist_item_attr_ids.get(0).expect("ignore"), &mut RbumItemAttrModifyReq { value: column_val }, funs, ctx).await?;
                 }
             }
         }
@@ -1222,6 +1221,7 @@ impl RbumItemAttrServ {
                     ctx,
                 )
                 .await?;
+            // TODO check logic
                 let result = if in_secret_table_attr.dyn_default_value.is_empty() {
                     if RbumKindAttrServ::url_match(&in_secret_table_attr.dyn_default_value).unwrap() {
                         let url = RbumKindAttrServ::url_replace(&in_secret_table_attr.dyn_default_value, add_req.values.clone()).unwrap();
@@ -1252,7 +1252,7 @@ impl RbumItemAttrServ {
                     )
                     .await?;
                 } else {
-                    Self::modify_rbum(secret_item_attr_ids.get(0).unwrap(), &mut RbumItemAttrModifyReq { value: result }, funs, ctx).await?;
+                    Self::modify_rbum(secret_item_attr_ids.get(0).expect("ignore"), &mut RbumItemAttrModifyReq { value: result }, funs, ctx).await?;
                 }
             }
         }
diff --git a/backend/basic/src/rbum/serv/rbum_set_serv.rs b/backend/basic/src/rbum/serv/rbum_set_serv.rs
index 3feb0109b..ecf5359ff 100644
--- a/backend/basic/src/rbum/serv/rbum_set_serv.rs
+++ b/backend/basic/src/rbum/serv/rbum_set_serv.rs
@@ -329,7 +329,7 @@ impl RbumSetServ {
                     tree_main
                         .iter()
                         .filter(|c| c.sys_code.starts_with(&cate.sys_code))
-                        .flat_map(|c| items.get(&c.id).unwrap())
+                        .flat_map(|c| items.get(&c.id).expect("ignore"))
                         .group_by(|c| c.rel_rbum_item_kind_id.clone())
                         .into_iter()
                         .map(|(g, c)| (g, c.map(|i| i.rel_rbum_item_id.clone()).collect::<HashSet<String>>().len() as u64))
@@ -377,6 +377,7 @@ impl RbumSetServ {
             .filter(|cate| cate.pid == Some(cate_id.to_string()))
             .flat_map(|cate| Self::filter_exist_items(tree_main, &cate.id, rbum_set_items))
             .collect::<Vec<String>>();
+        // TODO remove unwrap
         let cate = tree_main.iter().find(|cate| cate.id == cate_id).unwrap();
         if sub_cates.is_empty() {
             // leaf node
diff --git a/backend/basic/src/spi/spi_funs.rs b/backend/basic/src/spi/spi_funs.rs
index 99293b4eb..ae6df8f63 100644
--- a/backend/basic/src/spi/spi_funs.rs
+++ b/backend/basic/src/spi/spi_funs.rs
@@ -33,12 +33,12 @@ impl SpiBsInst {
     where
         T: 'static,
     {
-        let c = self.client.as_ref().downcast_ref::<T>().unwrap();
+        let c = self.client.as_ref().downcast_ref::<T>().expect("ignore");
         (c, &self.ext, self.kind_code())
     }
 
     pub fn kind_code(&self) -> &str {
-        self.ext.get(spi_constants::SPI_KIND_CODE_FLAG).unwrap()
+        self.ext.get(spi_constants::SPI_KIND_CODE_FLAG).expect("ignore")
     }
 }
 
diff --git a/backend/basic/src/spi/spi_initializer.rs b/backend/basic/src/spi/spi_initializer.rs
index 16e6f1ca8..3c8b4470c 100644
--- a/backend/basic/src/spi/spi_initializer.rs
+++ b/backend/basic/src/spi/spi_initializer.rs
@@ -240,8 +240,8 @@ pub mod common_pg {
         let compatible_type = TardisFuns::json.json_to_obj(ext.get("compatible_type").unwrap_or(&tardis::serde_json::Value::String("None".to_string())).clone())?;
         let client = TardisRelDBClient::init(&DBModuleConfig {
             url: bs_cert.conn_uri.parse().expect("invalid url"),
-            max_connections: ext.get("max_connections").unwrap().as_u64().unwrap() as u32,
-            min_connections: ext.get("min_connections").unwrap().as_u64().unwrap() as u32,
+            max_connections: ext.get("max_connections").map(|c| c.as_u64()).flatten().unwrap_or(5) as u32,
+            min_connections: ext.get("min_connections").map(|c| c.as_u64()).flatten().unwrap_or(1) as u32,
             connect_timeout_sec: None,
             idle_timeout_sec: None,
             compatible_type,
@@ -289,7 +289,7 @@ pub mod common_pg {
     ) -> TardisResult<(TardisRelDBlConnection, String)> {
         let tag = tag.map(|t| format!("_{t}")).unwrap_or_default();
         let conn = bs_inst.0.conn();
-        let schema_name = get_schema_name_from_ext(bs_inst.1).unwrap();
+        let schema_name = get_schema_name_from_ext(bs_inst.1).expect("ignore");
         if check_table_exit(&format!("{table_flag}{tag}"), &conn, ctx).await? {
             return Ok((conn, format!("{schema_name}.{GLOBAL_STORAGE_FLAG}_{table_flag}{tag}")));
         } else if !mgr {
@@ -303,7 +303,7 @@ pub mod common_pg {
     /// 初始化连接
     pub async fn init_conn(bs_inst: TypedSpiBsInst<'_, TardisRelDBClient>) -> TardisResult<(TardisRelDBlConnection, String)> {
         let conn = bs_inst.0.conn();
-        let schema_name = get_schema_name_from_ext(bs_inst.1).unwrap();
+        let schema_name = get_schema_name_from_ext(bs_inst.1).expect("ignore");
         Ok((conn, schema_name))
     }
 
diff --git a/backend/gateways/test/src/init_apisix.rs b/backend/gateways/test/src/init_apisix.rs
deleted file mode 100644
index 824e29d10..000000000
--- a/backend/gateways/test/src/init_apisix.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-use tardis::basic::result::TardisResult;
-use tardis::serde_json::json;
-use tardis::testcontainers::clients::Cli;
-use tardis::testcontainers::core::WaitFor;
-use tardis::testcontainers::{Container, GenericImage, RunnableImage};
-use tardis::TardisFuns;
-
-pub(crate) async fn init(docker: &Cli) -> TardisResult<(String, Container<GenericImage>)> {
-    // Build docker image
-    let (_code, output, _error) = run_script::run_script!(
-        r#"
-         docker rm -f apisix_test
-         docker build -f gateways/test/conf/apisix/Dockerfile_with_etcd -t apisix_test gateways/
-         "#
-    )
-    .unwrap();
-    // println!("Exit Code: {}", code);
-    // println!("Error: {}", error);
-    println!("Output: {}", output);
-
-    // Start docker container
-    let image = GenericImage::new("apisix_test", "latest").with_wait_for(WaitFor::seconds(15));
-    let mut runnable_image: RunnableImage<GenericImage> = image.into();
-    runnable_image = runnable_image.with_network("host");
-    runnable_image = runnable_image.with_container_name("apisix_test");
-    let node = docker.run(runnable_image);
-    let url = "http://127.0.0.1:9080";
-    // Init routes
-    TardisFuns::web_client()
-        .put_obj_to_str(
-            &format!("{url}/apisix/admin/routes/1"),
-            &json!({
-                "uri": "/*",
-                "plugins": {
-                    "auth-bios": {
-                        "host": "http://127.0.0.1:8080/auth",
-                        "timeout": 60000
-                    }
-                },
-                "upstream": {
-                    "type": "roundrobin",
-                    "nodes": {
-                        "127.0.0.1:8080": 1
-                    }
-                }
-            }),
-            vec![("X-API-KEY".to_string(), "edd1c9f034335f136f87ad84b6acecs1".to_string())],
-        )
-        .await?;
-    Ok((url.to_string(), node))
-}