move to checks

Author: giladwolff

examples/register_service.rs

@@ -27,7 +27,7 @@ async fn main() {
             Port: Some(42424),
             Namespace: None,
         }),
-        Check: None,
+        Checks: Vec::new(),
         SkipNodeUpdate: None,
     };
     consul.register_entity(&payload).await.unwrap();

src/types.rs

@@ -312,9 +312,8 @@ pub struct RegisterEntityPayload {
     /// Optional service to register.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub Service: Option<RegisterEntityService>,
-    /// Optional check to register
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub Check: Option<RegisterEntityCheck>,
+    /// Checks to register.
+    pub Checks: Vec<RegisterEntityCheck>,
     /// Whether to skip updating the nodes information in the registration.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub SkipNodeUpdate: Option<bool>,

tests/test_runner.rs

@@ -1,4 +1,5 @@
 use rs_consul::*;
+use std::collections::HashMap;
 
 #[path = "utils/test_setup.rs"]
 mod test_setup;
@@ -304,4 +305,35 @@ mod tests {
         assert_eq!(string_value4, &value.unwrap());
         assert_ne!(mod_idx3, mod_idx4);
     }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_register_with_health_checks() {
+        let consul = get_client();
+
+        let new_service_name = "test-service-99".to_string();
+        let checks = [
+            RegisterEntityCheck {
+                Node: None,
+                CheckID: None,
+                Name: "Service Check".to_string(),
+                Notes: None,
+                Status: Some("passing".to_string()),
+                ServiceID: Some(service_id(&new_service_name)),
+                Definition: HashMap::new(),
+            },
+            RegisterEntityCheck {
+                Node: Some("local".to_string()),
+                CheckID: None,
+                Name: "Node check".to_string(),
+                Notes: None,
+                Status: Some("passing".to_string()),
+                ServiceID: None,
+                Definition: HashMap::new(),
+            },
+        ]
+        .to_vec();
+        register_entity_with_checks(&consul, &new_service_name, "local", checks).await;
+
+        assert!(is_registered(&consul, &new_service_name).await);
+    }
 }

tests/utils/test_setup.rs

@@ -31,7 +31,7 @@ pub(crate) async fn register_entity(consul: &Consul, service_name: &String, node
             Port: Some(42424),
             Namespace: None,
         }),
-        Check: None,
+        Checks: Vec::new(),
         SkipNodeUpdate: None,
     };
     consul
@@ -40,6 +40,50 @@ pub(crate) async fn register_entity(consul: &Consul, service_name: &String, node
         .expect("expected register_entity request to succeed");
 }
 
+pub(crate) async fn register_entity_with_checks(
+    consul: &Consul,
+    service_name: &String,
+    node_id: &str,
+    checks: Vec<RegisterEntityCheck>,
+) {
+    let ResponseMeta {
+        response: service_names_before_register,
+        ..
+    } = consul
+        .get_all_registered_service_names(None)
+        .await
+        .expect("expected get_registered_service_names request to succeed");
+    assert!(!service_names_before_register.contains(service_name));
+
+    let payload = RegisterEntityPayload {
+        ID: None,
+        Node: node_id.to_string(),
+        Address: "127.0.0.1".to_string(),
+        Datacenter: None,
+        TaggedAddresses: Default::default(),
+        NodeMeta: Default::default(),
+        Service: Some(RegisterEntityService {
+            ID: Some(service_id(service_name)),
+            Service: service_name.clone(),
+            Tags: vec![],
+            TaggedAddresses: Default::default(),
+            Meta: Default::default(),
+            Port: Some(42424),
+            Namespace: None,
+        }),
+        Checks: checks,
+        SkipNodeUpdate: None,
+    };
+    consul
+        .register_entity(&payload)
+        .await
+        .expect("expected register_entity request to succeed");
+}
+
+pub(crate) fn service_id(service_name: &str) -> String {
+    format!("{service_name}-ID")
+}
+
 pub(crate) async fn is_registered(consul: &Consul, service_name: &String) -> bool {
     let ResponseMeta {
         response: service_names_after_register,